diff --git a/.editorconfig b/.editorconfig
index 2e3045fb1..c28089d72 100644
--- a/.editorconfig
+++ b/.editorconfig
@@ -172,6 +172,8 @@ dotnet_diagnostic.IDE0063.severity = suggestion
 csharp_using_directive_placement = outside_namespace:warning
 # Modifier preferences
 csharp_prefer_static_local_function = true:warning
+# Primary constructor preferences
+csharp_style_prefer_primary_constructors = false:none
 
 ##########################################
 # Unnecessary Code Rules
diff --git a/ImageSharp.sln b/ImageSharp.sln
index 2967acb8f..b8204c47d 100644
--- a/ImageSharp.sln
+++ b/ImageSharp.sln
@@ -38,6 +38,7 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "src", "{815C0625-CD3
 		src\Directory.Build.props = src\Directory.Build.props
 		src\Directory.Build.targets = src\Directory.Build.targets
 		src\README.md = src\README.md
+		src\ImageSharp.ruleset = src\ImageSharp.ruleset
 	EndProjectSection
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ImageSharp", "src\ImageSharp\ImageSharp.csproj", "{2AA31A1F-142C-43F4-8687-09ABCA4B3A26}"
diff --git a/shared-infrastructure b/shared-infrastructure
index 1c526a97e..1dbfb576c 160000
--- a/shared-infrastructure
+++ b/shared-infrastructure
@@ -1 +1 @@
-Subproject commit 1c526a97eea8bcbc7c79de095676f7fb975a9fb1
+Subproject commit 1dbfb576c83507645265c79e03369b66cdc0379f
diff --git a/src/ImageSharp.ruleset b/src/ImageSharp.ruleset
index d7a147df0..b60989020 100644
--- a/src/ImageSharp.ruleset
+++ b/src/ImageSharp.ruleset
@@ -1,7 +1,4 @@
 <?xml version="1.0" encoding="utf-8"?>
 <RuleSet Name="ImageSharp" ToolsVersion="17.0">
   <Include Path="..\shared-infrastructure\sixlabors.ruleset" Action="Default" />
-  <Rules AnalyzerId="StyleCop.Analyzers" RuleNamespace="StyleCop.Analyzers">
-    <Rule Id="SA1011" Action="None" />
-  </Rules>
-</RuleSet>
+</RuleSet>
\ No newline at end of file
diff --git a/src/ImageSharp/Color/Color.Conversions.cs b/src/ImageSharp/Color/Color.Conversions.cs
deleted file mode 100644
index 309ab83ec..000000000
--- a/src/ImageSharp/Color/Color.Conversions.cs
+++ /dev/null
@@ -1,240 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-
-using System.Numerics;
-using System.Runtime.CompilerServices;
-using SixLabors.ImageSharp.PixelFormats;
-
-namespace SixLabors.ImageSharp;
-
-/// <content>
-/// Contains constructors and implicit conversion methods.
-/// </content>
-public readonly partial struct Color
-{
-    /// <summary>
-    /// Initializes a new instance of the <see cref="Color"/> struct.
-    /// </summary>
-    /// <param name="pixel">The <see cref="Rgba64"/> containing the color information.</param>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public Color(Rgba64 pixel)
-    {
-        this.data = pixel;
-        this.boxedHighPrecisionPixel = null;
-    }
-
-    /// <summary>
-    /// Initializes a new instance of the <see cref="Color"/> struct.
-    /// </summary>
-    /// <param name="pixel">The <see cref="Rgb48"/> containing the color information.</param>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public Color(Rgb48 pixel)
-    {
-        this.data = new Rgba64(pixel.R, pixel.G, pixel.B, ushort.MaxValue);
-        this.boxedHighPrecisionPixel = null;
-    }
-
-    /// <summary>
-    /// Initializes a new instance of the <see cref="Color"/> struct.
-    /// </summary>
-    /// <param name="pixel">The <see cref="La32"/> containing the color information.</param>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public Color(La32 pixel)
-    {
-        this.data = new Rgba64(pixel.L, pixel.L, pixel.L, pixel.A);
-        this.boxedHighPrecisionPixel = null;
-    }
-
-    /// <summary>
-    /// Initializes a new instance of the <see cref="Color"/> struct.
-    /// </summary>
-    /// <param name="pixel">The <see cref="L16"/> containing the color information.</param>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public Color(L16 pixel)
-    {
-        this.data = new Rgba64(pixel.PackedValue, pixel.PackedValue, pixel.PackedValue, ushort.MaxValue);
-        this.boxedHighPrecisionPixel = null;
-    }
-
-    /// <summary>
-    /// Initializes a new instance of the <see cref="Color"/> struct.
-    /// </summary>
-    /// <param name="pixel">The <see cref="Rgba32"/> containing the color information.</param>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public Color(Rgba32 pixel)
-    {
-        this.data = new Rgba64(pixel);
-        this.boxedHighPrecisionPixel = null;
-    }
-
-    /// <summary>
-    /// Initializes a new instance of the <see cref="Color"/> struct.
-    /// </summary>
-    /// <param name="pixel">The <see cref="Argb32"/> containing the color information.</param>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public Color(Argb32 pixel)
-    {
-        this.data = new Rgba64(pixel);
-        this.boxedHighPrecisionPixel = null;
-    }
-
-    /// <summary>
-    /// Initializes a new instance of the <see cref="Color"/> struct.
-    /// </summary>
-    /// <param name="pixel">The <see cref="Bgra32"/> containing the color information.</param>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public Color(Bgra32 pixel)
-    {
-        this.data = new Rgba64(pixel);
-        this.boxedHighPrecisionPixel = null;
-    }
-
-    /// <summary>
-    /// Initializes a new instance of the <see cref="Color"/> struct.
-    /// </summary>
-    /// <param name="pixel">The <see cref="Abgr32"/> containing the color information.</param>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public Color(Abgr32 pixel)
-    {
-        this.data = new Rgba64(pixel);
-        this.boxedHighPrecisionPixel = null;
-    }
-
-    /// <summary>
-    /// Initializes a new instance of the <see cref="Color"/> struct.
-    /// </summary>
-    /// <param name="pixel">The <see cref="Rgb24"/> containing the color information.</param>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public Color(Rgb24 pixel)
-    {
-        this.data = new Rgba64(pixel);
-        this.boxedHighPrecisionPixel = null;
-    }
-
-    /// <summary>
-    /// Initializes a new instance of the <see cref="Color"/> struct.
-    /// </summary>
-    /// <param name="pixel">The <see cref="Bgr24"/> containing the color information.</param>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public Color(Bgr24 pixel)
-    {
-        this.data = new Rgba64(pixel);
-        this.boxedHighPrecisionPixel = null;
-    }
-
-    /// <summary>
-    /// Initializes a new instance of the <see cref="Color"/> struct.
-    /// </summary>
-    /// <param name="vector">The <see cref="Vector4"/> containing the color information.</param>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public Color(Vector4 vector)
-    {
-        vector = Numerics.Clamp(vector, Vector4.Zero, Vector4.One);
-        this.boxedHighPrecisionPixel = new RgbaVector(vector.X, vector.Y, vector.Z, vector.W);
-        this.data = default;
-    }
-
-    /// <summary>
-    /// Converts a <see cref="Color"/> to <see cref="Vector4"/>.
-    /// </summary>
-    /// <param name="color">The <see cref="Color"/>.</param>
-    /// <returns>The <see cref="Vector4"/>.</returns>
-    public static explicit operator Vector4(Color color) => color.ToScaledVector4();
-
-    /// <summary>
-    /// Converts an <see cref="Vector4"/> to <see cref="Color"/>.
-    /// </summary>
-    /// <param name="source">The <see cref="Vector4"/>.</param>
-    /// <returns>The <see cref="Color"/>.</returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public static explicit operator Color(Vector4 source) => new(source);
-
-    [MethodImpl(InliningOptions.ShortMethod)]
-    internal Rgba32 ToRgba32()
-    {
-        if (this.boxedHighPrecisionPixel is null)
-        {
-            return this.data.ToRgba32();
-        }
-
-        Rgba32 value = default;
-        this.boxedHighPrecisionPixel.ToRgba32(ref value);
-        return value;
-    }
-
-    [MethodImpl(InliningOptions.ShortMethod)]
-    internal Bgra32 ToBgra32()
-    {
-        if (this.boxedHighPrecisionPixel is null)
-        {
-            return this.data.ToBgra32();
-        }
-
-        Bgra32 value = default;
-        value.FromScaledVector4(this.boxedHighPrecisionPixel.ToScaledVector4());
-        return value;
-    }
-
-    [MethodImpl(InliningOptions.ShortMethod)]
-    internal Argb32 ToArgb32()
-    {
-        if (this.boxedHighPrecisionPixel is null)
-        {
-            return this.data.ToArgb32();
-        }
-
-        Argb32 value = default;
-        value.FromScaledVector4(this.boxedHighPrecisionPixel.ToScaledVector4());
-        return value;
-    }
-
-    [MethodImpl(InliningOptions.ShortMethod)]
-    internal Abgr32 ToAbgr32()
-    {
-        if (this.boxedHighPrecisionPixel is null)
-        {
-            return this.data.ToAbgr32();
-        }
-
-        Abgr32 value = default;
-        value.FromScaledVector4(this.boxedHighPrecisionPixel.ToScaledVector4());
-        return value;
-    }
-
-    [MethodImpl(InliningOptions.ShortMethod)]
-    internal Rgb24 ToRgb24()
-    {
-        if (this.boxedHighPrecisionPixel is null)
-        {
-            return this.data.ToRgb24();
-        }
-
-        Rgb24 value = default;
-        value.FromScaledVector4(this.boxedHighPrecisionPixel.ToScaledVector4());
-        return value;
-    }
-
-    [MethodImpl(InliningOptions.ShortMethod)]
-    internal Bgr24 ToBgr24()
-    {
-        if (this.boxedHighPrecisionPixel is null)
-        {
-            return this.data.ToBgr24();
-        }
-
-        Bgr24 value = default;
-        value.FromScaledVector4(this.boxedHighPrecisionPixel.ToScaledVector4());
-        return value;
-    }
-
-    [MethodImpl(InliningOptions.ShortMethod)]
-    internal Vector4 ToScaledVector4()
-    {
-        if (this.boxedHighPrecisionPixel is null)
-        {
-            return this.data.ToScaledVector4();
-        }
-
-        return this.boxedHighPrecisionPixel.ToScaledVector4();
-    }
-}
diff --git a/src/ImageSharp/Color/Color.NamedColors.cs b/src/ImageSharp/Color/Color.NamedColors.cs
index f8b4c90fd..00130dd90 100644
--- a/src/ImageSharp/Color/Color.NamedColors.cs
+++ b/src/ImageSharp/Color/Color.NamedColors.cs
@@ -1,6 +1,8 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using SixLabors.ImageSharp.PixelFormats;
+
 namespace SixLabors.ImageSharp;
 
 /// <content>
@@ -9,107 +11,107 @@ namespace SixLabors.ImageSharp;
 /// </content>
 public readonly partial struct Color
 {
-    private static readonly Lazy<Dictionary<string, Color>> NamedColorsLookupLazy = new Lazy<Dictionary<string, Color>>(CreateNamedColorsLookup, true);
+    private static readonly Lazy<Dictionary<string, Color>> NamedColorsLookupLazy = new(CreateNamedColorsLookup, true);
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #F0F8FF.
     /// </summary>
-    public static readonly Color AliceBlue = FromRgba(240, 248, 255, 255);
+    public static readonly Color AliceBlue = FromPixel(new Rgba32(240, 248, 255, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #FAEBD7.
     /// </summary>
-    public static readonly Color AntiqueWhite = FromRgba(250, 235, 215, 255);
+    public static readonly Color AntiqueWhite = FromPixel(new Rgba32(250, 235, 215, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #00FFFF.
     /// </summary>
-    public static readonly Color Aqua = FromRgba(0, 255, 255, 255);
+    public static readonly Color Aqua = FromPixel(new Rgba32(0, 255, 255, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #7FFFD4.
     /// </summary>
-    public static readonly Color Aquamarine = FromRgba(127, 255, 212, 255);
+    public static readonly Color Aquamarine = FromPixel(new Rgba32(127, 255, 212, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #F0FFFF.
     /// </summary>
-    public static readonly Color Azure = FromRgba(240, 255, 255, 255);
+    public static readonly Color Azure = FromPixel(new Rgba32(240, 255, 255, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #F5F5DC.
     /// </summary>
-    public static readonly Color Beige = FromRgba(245, 245, 220, 255);
+    public static readonly Color Beige = FromPixel(new Rgba32(245, 245, 220, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #FFE4C4.
     /// </summary>
-    public static readonly Color Bisque = FromRgba(255, 228, 196, 255);
+    public static readonly Color Bisque = FromPixel(new Rgba32(255, 228, 196, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #000000.
     /// </summary>
-    public static readonly Color Black = FromRgba(0, 0, 0, 255);
+    public static readonly Color Black = FromPixel(new Rgba32(0, 0, 0, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #FFEBCD.
     /// </summary>
-    public static readonly Color BlanchedAlmond = FromRgba(255, 235, 205, 255);
+    public static readonly Color BlanchedAlmond = FromPixel(new Rgba32(255, 235, 205, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #0000FF.
     /// </summary>
-    public static readonly Color Blue = FromRgba(0, 0, 255, 255);
+    public static readonly Color Blue = FromPixel(new Rgba32(0, 0, 255, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #8A2BE2.
     /// </summary>
-    public static readonly Color BlueViolet = FromRgba(138, 43, 226, 255);
+    public static readonly Color BlueViolet = FromPixel(new Rgba32(138, 43, 226, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #A52A2A.
     /// </summary>
-    public static readonly Color Brown = FromRgba(165, 42, 42, 255);
+    public static readonly Color Brown = FromPixel(new Rgba32(165, 42, 42, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #DEB887.
     /// </summary>
-    public static readonly Color BurlyWood = FromRgba(222, 184, 135, 255);
+    public static readonly Color BurlyWood = FromPixel(new Rgba32(222, 184, 135, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #5F9EA0.
     /// </summary>
-    public static readonly Color CadetBlue = FromRgba(95, 158, 160, 255);
+    public static readonly Color CadetBlue = FromPixel(new Rgba32(95, 158, 160, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #7FFF00.
     /// </summary>
-    public static readonly Color Chartreuse = FromRgba(127, 255, 0, 255);
+    public static readonly Color Chartreuse = FromPixel(new Rgba32(127, 255, 0, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #D2691E.
     /// </summary>
-    public static readonly Color Chocolate = FromRgba(210, 105, 30, 255);
+    public static readonly Color Chocolate = FromPixel(new Rgba32(210, 105, 30, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #FF7F50.
     /// </summary>
-    public static readonly Color Coral = FromRgba(255, 127, 80, 255);
+    public static readonly Color Coral = FromPixel(new Rgba32(255, 127, 80, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #6495ED.
     /// </summary>
-    public static readonly Color CornflowerBlue = FromRgba(100, 149, 237, 255);
+    public static readonly Color CornflowerBlue = FromPixel(new Rgba32(100, 149, 237, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #FFF8DC.
     /// </summary>
-    public static readonly Color Cornsilk = FromRgba(255, 248, 220, 255);
+    public static readonly Color Cornsilk = FromPixel(new Rgba32(255, 248, 220, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #DC143C.
     /// </summary>
-    public static readonly Color Crimson = FromRgba(220, 20, 60, 255);
+    public static readonly Color Crimson = FromPixel(new Rgba32(220, 20, 60, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #00FFFF.
@@ -119,27 +121,27 @@ public readonly partial struct Color
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #00008B.
     /// </summary>
-    public static readonly Color DarkBlue = FromRgba(0, 0, 139, 255);
+    public static readonly Color DarkBlue = FromPixel(new Rgba32(0, 0, 139, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #008B8B.
     /// </summary>
-    public static readonly Color DarkCyan = FromRgba(0, 139, 139, 255);
+    public static readonly Color DarkCyan = FromPixel(new Rgba32(0, 139, 139, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #B8860B.
     /// </summary>
-    public static readonly Color DarkGoldenrod = FromRgba(184, 134, 11, 255);
+    public static readonly Color DarkGoldenrod = FromPixel(new Rgba32(184, 134, 11, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #A9A9A9.
     /// </summary>
-    public static readonly Color DarkGray = FromRgba(169, 169, 169, 255);
+    public static readonly Color DarkGray = FromPixel(new Rgba32(169, 169, 169, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #006400.
     /// </summary>
-    public static readonly Color DarkGreen = FromRgba(0, 100, 0, 255);
+    public static readonly Color DarkGreen = FromPixel(new Rgba32(0, 100, 0, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #A9A9A9.
@@ -149,52 +151,52 @@ public readonly partial struct Color
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #BDB76B.
     /// </summary>
-    public static readonly Color DarkKhaki = FromRgba(189, 183, 107, 255);
+    public static readonly Color DarkKhaki = FromPixel(new Rgba32(189, 183, 107, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #8B008B.
     /// </summary>
-    public static readonly Color DarkMagenta = FromRgba(139, 0, 139, 255);
+    public static readonly Color DarkMagenta = FromPixel(new Rgba32(139, 0, 139, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #556B2F.
     /// </summary>
-    public static readonly Color DarkOliveGreen = FromRgba(85, 107, 47, 255);
+    public static readonly Color DarkOliveGreen = FromPixel(new Rgba32(85, 107, 47, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #FF8C00.
     /// </summary>
-    public static readonly Color DarkOrange = FromRgba(255, 140, 0, 255);
+    public static readonly Color DarkOrange = FromPixel(new Rgba32(255, 140, 0, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #9932CC.
     /// </summary>
-    public static readonly Color DarkOrchid = FromRgba(153, 50, 204, 255);
+    public static readonly Color DarkOrchid = FromPixel(new Rgba32(153, 50, 204, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #8B0000.
     /// </summary>
-    public static readonly Color DarkRed = FromRgba(139, 0, 0, 255);
+    public static readonly Color DarkRed = FromPixel(new Rgba32(139, 0, 0, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #E9967A.
     /// </summary>
-    public static readonly Color DarkSalmon = FromRgba(233, 150, 122, 255);
+    public static readonly Color DarkSalmon = FromPixel(new Rgba32(233, 150, 122, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #8FBC8F.
     /// </summary>
-    public static readonly Color DarkSeaGreen = FromRgba(143, 188, 143, 255);
+    public static readonly Color DarkSeaGreen = FromPixel(new Rgba32(143, 188, 143, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #483D8B.
     /// </summary>
-    public static readonly Color DarkSlateBlue = FromRgba(72, 61, 139, 255);
+    public static readonly Color DarkSlateBlue = FromPixel(new Rgba32(72, 61, 139, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #2F4F4F.
     /// </summary>
-    public static readonly Color DarkSlateGray = FromRgba(47, 79, 79, 255);
+    public static readonly Color DarkSlateGray = FromPixel(new Rgba32(47, 79, 79, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #2F4F4F.
@@ -204,27 +206,27 @@ public readonly partial struct Color
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #00CED1.
     /// </summary>
-    public static readonly Color DarkTurquoise = FromRgba(0, 206, 209, 255);
+    public static readonly Color DarkTurquoise = FromPixel(new Rgba32(0, 206, 209, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #9400D3.
     /// </summary>
-    public static readonly Color DarkViolet = FromRgba(148, 0, 211, 255);
+    public static readonly Color DarkViolet = FromPixel(new Rgba32(148, 0, 211, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #FF1493.
     /// </summary>
-    public static readonly Color DeepPink = FromRgba(255, 20, 147, 255);
+    public static readonly Color DeepPink = FromPixel(new Rgba32(255, 20, 147, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #00BFFF.
     /// </summary>
-    public static readonly Color DeepSkyBlue = FromRgba(0, 191, 255, 255);
+    public static readonly Color DeepSkyBlue = FromPixel(new Rgba32(0, 191, 255, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #696969.
     /// </summary>
-    public static readonly Color DimGray = FromRgba(105, 105, 105, 255);
+    public static readonly Color DimGray = FromPixel(new Rgba32(105, 105, 105, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #696969.
@@ -234,62 +236,62 @@ public readonly partial struct Color
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #1E90FF.
     /// </summary>
-    public static readonly Color DodgerBlue = FromRgba(30, 144, 255, 255);
+    public static readonly Color DodgerBlue = FromPixel(new Rgba32(30, 144, 255, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #B22222.
     /// </summary>
-    public static readonly Color Firebrick = FromRgba(178, 34, 34, 255);
+    public static readonly Color Firebrick = FromPixel(new Rgba32(178, 34, 34, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #FFFAF0.
     /// </summary>
-    public static readonly Color FloralWhite = FromRgba(255, 250, 240, 255);
+    public static readonly Color FloralWhite = FromPixel(new Rgba32(255, 250, 240, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #228B22.
     /// </summary>
-    public static readonly Color ForestGreen = FromRgba(34, 139, 34, 255);
+    public static readonly Color ForestGreen = FromPixel(new Rgba32(34, 139, 34, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #FF00FF.
     /// </summary>
-    public static readonly Color Fuchsia = FromRgba(255, 0, 255, 255);
+    public static readonly Color Fuchsia = FromPixel(new Rgba32(255, 0, 255, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #DCDCDC.
     /// </summary>
-    public static readonly Color Gainsboro = FromRgba(220, 220, 220, 255);
+    public static readonly Color Gainsboro = FromPixel(new Rgba32(220, 220, 220, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #F8F8FF.
     /// </summary>
-    public static readonly Color GhostWhite = FromRgba(248, 248, 255, 255);
+    public static readonly Color GhostWhite = FromPixel(new Rgba32(248, 248, 255, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #FFD700.
     /// </summary>
-    public static readonly Color Gold = FromRgba(255, 215, 0, 255);
+    public static readonly Color Gold = FromPixel(new Rgba32(255, 215, 0, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #DAA520.
     /// </summary>
-    public static readonly Color Goldenrod = FromRgba(218, 165, 32, 255);
+    public static readonly Color Goldenrod = FromPixel(new Rgba32(218, 165, 32, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #808080.
     /// </summary>
-    public static readonly Color Gray = FromRgba(128, 128, 128, 255);
+    public static readonly Color Gray = FromPixel(new Rgba32(128, 128, 128, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #008000.
     /// </summary>
-    public static readonly Color Green = FromRgba(0, 128, 0, 255);
+    public static readonly Color Green = FromPixel(new Rgba32(0, 128, 0, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #ADFF2F.
     /// </summary>
-    public static readonly Color GreenYellow = FromRgba(173, 255, 47, 255);
+    public static readonly Color GreenYellow = FromPixel(new Rgba32(173, 255, 47, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #808080.
@@ -299,82 +301,82 @@ public readonly partial struct Color
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #F0FFF0.
     /// </summary>
-    public static readonly Color Honeydew = FromRgba(240, 255, 240, 255);
+    public static readonly Color Honeydew = FromPixel(new Rgba32(240, 255, 240, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #FF69B4.
     /// </summary>
-    public static readonly Color HotPink = FromRgba(255, 105, 180, 255);
+    public static readonly Color HotPink = FromPixel(new Rgba32(255, 105, 180, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #CD5C5C.
     /// </summary>
-    public static readonly Color IndianRed = FromRgba(205, 92, 92, 255);
+    public static readonly Color IndianRed = FromPixel(new Rgba32(205, 92, 92, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #4B0082.
     /// </summary>
-    public static readonly Color Indigo = FromRgba(75, 0, 130, 255);
+    public static readonly Color Indigo = FromPixel(new Rgba32(75, 0, 130, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #FFFFF0.
     /// </summary>
-    public static readonly Color Ivory = FromRgba(255, 255, 240, 255);
+    public static readonly Color Ivory = FromPixel(new Rgba32(255, 255, 240, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #F0E68C.
     /// </summary>
-    public static readonly Color Khaki = FromRgba(240, 230, 140, 255);
+    public static readonly Color Khaki = FromPixel(new Rgba32(240, 230, 140, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #E6E6FA.
     /// </summary>
-    public static readonly Color Lavender = FromRgba(230, 230, 250, 255);
+    public static readonly Color Lavender = FromPixel(new Rgba32(230, 230, 250, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #FFF0F5.
     /// </summary>
-    public static readonly Color LavenderBlush = FromRgba(255, 240, 245, 255);
+    public static readonly Color LavenderBlush = FromPixel(new Rgba32(255, 240, 245, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #7CFC00.
     /// </summary>
-    public static readonly Color LawnGreen = FromRgba(124, 252, 0, 255);
+    public static readonly Color LawnGreen = FromPixel(new Rgba32(124, 252, 0, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #FFFACD.
     /// </summary>
-    public static readonly Color LemonChiffon = FromRgba(255, 250, 205, 255);
+    public static readonly Color LemonChiffon = FromPixel(new Rgba32(255, 250, 205, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #ADD8E6.
     /// </summary>
-    public static readonly Color LightBlue = FromRgba(173, 216, 230, 255);
+    public static readonly Color LightBlue = FromPixel(new Rgba32(173, 216, 230, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #F08080.
     /// </summary>
-    public static readonly Color LightCoral = FromRgba(240, 128, 128, 255);
+    public static readonly Color LightCoral = FromPixel(new Rgba32(240, 128, 128, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #E0FFFF.
     /// </summary>
-    public static readonly Color LightCyan = FromRgba(224, 255, 255, 255);
+    public static readonly Color LightCyan = FromPixel(new Rgba32(224, 255, 255, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #FAFAD2.
     /// </summary>
-    public static readonly Color LightGoldenrodYellow = FromRgba(250, 250, 210, 255);
+    public static readonly Color LightGoldenrodYellow = FromPixel(new Rgba32(250, 250, 210, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #D3D3D3.
     /// </summary>
-    public static readonly Color LightGray = FromRgba(211, 211, 211, 255);
+    public static readonly Color LightGray = FromPixel(new Rgba32(211, 211, 211, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #90EE90.
     /// </summary>
-    public static readonly Color LightGreen = FromRgba(144, 238, 144, 255);
+    public static readonly Color LightGreen = FromPixel(new Rgba32(144, 238, 144, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #D3D3D3.
@@ -384,27 +386,27 @@ public readonly partial struct Color
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #FFB6C1.
     /// </summary>
-    public static readonly Color LightPink = FromRgba(255, 182, 193, 255);
+    public static readonly Color LightPink = FromPixel(new Rgba32(255, 182, 193, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #FFA07A.
     /// </summary>
-    public static readonly Color LightSalmon = FromRgba(255, 160, 122, 255);
+    public static readonly Color LightSalmon = FromPixel(new Rgba32(255, 160, 122, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #20B2AA.
     /// </summary>
-    public static readonly Color LightSeaGreen = FromRgba(32, 178, 170, 255);
+    public static readonly Color LightSeaGreen = FromPixel(new Rgba32(32, 178, 170, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #87CEFA.
     /// </summary>
-    public static readonly Color LightSkyBlue = FromRgba(135, 206, 250, 255);
+    public static readonly Color LightSkyBlue = FromPixel(new Rgba32(135, 206, 250, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #778899.
     /// </summary>
-    public static readonly Color LightSlateGray = FromRgba(119, 136, 153, 255);
+    public static readonly Color LightSlateGray = FromPixel(new Rgba32(119, 136, 153, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #778899.
@@ -414,27 +416,27 @@ public readonly partial struct Color
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #B0C4DE.
     /// </summary>
-    public static readonly Color LightSteelBlue = FromRgba(176, 196, 222, 255);
+    public static readonly Color LightSteelBlue = FromPixel(new Rgba32(176, 196, 222, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #FFFFE0.
     /// </summary>
-    public static readonly Color LightYellow = FromRgba(255, 255, 224, 255);
+    public static readonly Color LightYellow = FromPixel(new Rgba32(255, 255, 224, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #00FF00.
     /// </summary>
-    public static readonly Color Lime = FromRgba(0, 255, 0, 255);
+    public static readonly Color Lime = FromPixel(new Rgba32(0, 255, 0, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #32CD32.
     /// </summary>
-    public static readonly Color LimeGreen = FromRgba(50, 205, 50, 255);
+    public static readonly Color LimeGreen = FromPixel(new Rgba32(50, 205, 50, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #FAF0E6.
     /// </summary>
-    public static readonly Color Linen = FromRgba(250, 240, 230, 255);
+    public static readonly Color Linen = FromPixel(new Rgba32(250, 240, 230, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #FF00FF.
@@ -444,237 +446,237 @@ public readonly partial struct Color
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #800000.
     /// </summary>
-    public static readonly Color Maroon = FromRgba(128, 0, 0, 255);
+    public static readonly Color Maroon = FromPixel(new Rgba32(128, 0, 0, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #66CDAA.
     /// </summary>
-    public static readonly Color MediumAquamarine = FromRgba(102, 205, 170, 255);
+    public static readonly Color MediumAquamarine = FromPixel(new Rgba32(102, 205, 170, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #0000CD.
     /// </summary>
-    public static readonly Color MediumBlue = FromRgba(0, 0, 205, 255);
+    public static readonly Color MediumBlue = FromPixel(new Rgba32(0, 0, 205, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #BA55D3.
     /// </summary>
-    public static readonly Color MediumOrchid = FromRgba(186, 85, 211, 255);
+    public static readonly Color MediumOrchid = FromPixel(new Rgba32(186, 85, 211, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #9370DB.
     /// </summary>
-    public static readonly Color MediumPurple = FromRgba(147, 112, 219, 255);
+    public static readonly Color MediumPurple = FromPixel(new Rgba32(147, 112, 219, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #3CB371.
     /// </summary>
-    public static readonly Color MediumSeaGreen = FromRgba(60, 179, 113, 255);
+    public static readonly Color MediumSeaGreen = FromPixel(new Rgba32(60, 179, 113, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #7B68EE.
     /// </summary>
-    public static readonly Color MediumSlateBlue = FromRgba(123, 104, 238, 255);
+    public static readonly Color MediumSlateBlue = FromPixel(new Rgba32(123, 104, 238, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #00FA9A.
     /// </summary>
-    public static readonly Color MediumSpringGreen = FromRgba(0, 250, 154, 255);
+    public static readonly Color MediumSpringGreen = FromPixel(new Rgba32(0, 250, 154, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #48D1CC.
     /// </summary>
-    public static readonly Color MediumTurquoise = FromRgba(72, 209, 204, 255);
+    public static readonly Color MediumTurquoise = FromPixel(new Rgba32(72, 209, 204, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #C71585.
     /// </summary>
-    public static readonly Color MediumVioletRed = FromRgba(199, 21, 133, 255);
+    public static readonly Color MediumVioletRed = FromPixel(new Rgba32(199, 21, 133, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #191970.
     /// </summary>
-    public static readonly Color MidnightBlue = FromRgba(25, 25, 112, 255);
+    public static readonly Color MidnightBlue = FromPixel(new Rgba32(25, 25, 112, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #F5FFFA.
     /// </summary>
-    public static readonly Color MintCream = FromRgba(245, 255, 250, 255);
+    public static readonly Color MintCream = FromPixel(new Rgba32(245, 255, 250, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #FFE4E1.
     /// </summary>
-    public static readonly Color MistyRose = FromRgba(255, 228, 225, 255);
+    public static readonly Color MistyRose = FromPixel(new Rgba32(255, 228, 225, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #FFE4B5.
     /// </summary>
-    public static readonly Color Moccasin = FromRgba(255, 228, 181, 255);
+    public static readonly Color Moccasin = FromPixel(new Rgba32(255, 228, 181, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #FFDEAD.
     /// </summary>
-    public static readonly Color NavajoWhite = FromRgba(255, 222, 173, 255);
+    public static readonly Color NavajoWhite = FromPixel(new Rgba32(255, 222, 173, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #000080.
     /// </summary>
-    public static readonly Color Navy = FromRgba(0, 0, 128, 255);
+    public static readonly Color Navy = FromPixel(new Rgba32(0, 0, 128, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #FDF5E6.
     /// </summary>
-    public static readonly Color OldLace = FromRgba(253, 245, 230, 255);
+    public static readonly Color OldLace = FromPixel(new Rgba32(253, 245, 230, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #808000.
     /// </summary>
-    public static readonly Color Olive = FromRgba(128, 128, 0, 255);
+    public static readonly Color Olive = FromPixel(new Rgba32(128, 128, 0, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #6B8E23.
     /// </summary>
-    public static readonly Color OliveDrab = FromRgba(107, 142, 35, 255);
+    public static readonly Color OliveDrab = FromPixel(new Rgba32(107, 142, 35, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #FFA500.
     /// </summary>
-    public static readonly Color Orange = FromRgba(255, 165, 0, 255);
+    public static readonly Color Orange = FromPixel(new Rgba32(255, 165, 0, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #FF4500.
     /// </summary>
-    public static readonly Color OrangeRed = FromRgba(255, 69, 0, 255);
+    public static readonly Color OrangeRed = FromPixel(new Rgba32(255, 69, 0, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #DA70D6.
     /// </summary>
-    public static readonly Color Orchid = FromRgba(218, 112, 214, 255);
+    public static readonly Color Orchid = FromPixel(new Rgba32(218, 112, 214, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #EEE8AA.
     /// </summary>
-    public static readonly Color PaleGoldenrod = FromRgba(238, 232, 170, 255);
+    public static readonly Color PaleGoldenrod = FromPixel(new Rgba32(238, 232, 170, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #98FB98.
     /// </summary>
-    public static readonly Color PaleGreen = FromRgba(152, 251, 152, 255);
+    public static readonly Color PaleGreen = FromPixel(new Rgba32(152, 251, 152, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #AFEEEE.
     /// </summary>
-    public static readonly Color PaleTurquoise = FromRgba(175, 238, 238, 255);
+    public static readonly Color PaleTurquoise = FromPixel(new Rgba32(175, 238, 238, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #DB7093.
     /// </summary>
-    public static readonly Color PaleVioletRed = FromRgba(219, 112, 147, 255);
+    public static readonly Color PaleVioletRed = FromPixel(new Rgba32(219, 112, 147, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #FFEFD5.
     /// </summary>
-    public static readonly Color PapayaWhip = FromRgba(255, 239, 213, 255);
+    public static readonly Color PapayaWhip = FromPixel(new Rgba32(255, 239, 213, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #FFDAB9.
     /// </summary>
-    public static readonly Color PeachPuff = FromRgba(255, 218, 185, 255);
+    public static readonly Color PeachPuff = FromPixel(new Rgba32(255, 218, 185, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #CD853F.
     /// </summary>
-    public static readonly Color Peru = FromRgba(205, 133, 63, 255);
+    public static readonly Color Peru = FromPixel(new Rgba32(205, 133, 63, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #FFC0CB.
     /// </summary>
-    public static readonly Color Pink = FromRgba(255, 192, 203, 255);
+    public static readonly Color Pink = FromPixel(new Rgba32(255, 192, 203, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #DDA0DD.
     /// </summary>
-    public static readonly Color Plum = FromRgba(221, 160, 221, 255);
+    public static readonly Color Plum = FromPixel(new Rgba32(221, 160, 221, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #B0E0E6.
     /// </summary>
-    public static readonly Color PowderBlue = FromRgba(176, 224, 230, 255);
+    public static readonly Color PowderBlue = FromPixel(new Rgba32(176, 224, 230, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #800080.
     /// </summary>
-    public static readonly Color Purple = FromRgba(128, 0, 128, 255);
+    public static readonly Color Purple = FromPixel(new Rgba32(128, 0, 128, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #663399.
     /// </summary>
-    public static readonly Color RebeccaPurple = FromRgba(102, 51, 153, 255);
+    public static readonly Color RebeccaPurple = FromPixel(new Rgba32(102, 51, 153, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #FF0000.
     /// </summary>
-    public static readonly Color Red = FromRgba(255, 0, 0, 255);
+    public static readonly Color Red = FromPixel(new Rgba32(255, 0, 0, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #BC8F8F.
     /// </summary>
-    public static readonly Color RosyBrown = FromRgba(188, 143, 143, 255);
+    public static readonly Color RosyBrown = FromPixel(new Rgba32(188, 143, 143, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #4169E1.
     /// </summary>
-    public static readonly Color RoyalBlue = FromRgba(65, 105, 225, 255);
+    public static readonly Color RoyalBlue = FromPixel(new Rgba32(65, 105, 225, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #8B4513.
     /// </summary>
-    public static readonly Color SaddleBrown = FromRgba(139, 69, 19, 255);
+    public static readonly Color SaddleBrown = FromPixel(new Rgba32(139, 69, 19, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #FA8072.
     /// </summary>
-    public static readonly Color Salmon = FromRgba(250, 128, 114, 255);
+    public static readonly Color Salmon = FromPixel(new Rgba32(250, 128, 114, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #F4A460.
     /// </summary>
-    public static readonly Color SandyBrown = FromRgba(244, 164, 96, 255);
+    public static readonly Color SandyBrown = FromPixel(new Rgba32(244, 164, 96, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #2E8B57.
     /// </summary>
-    public static readonly Color SeaGreen = FromRgba(46, 139, 87, 255);
+    public static readonly Color SeaGreen = FromPixel(new Rgba32(46, 139, 87, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #FFF5EE.
     /// </summary>
-    public static readonly Color SeaShell = FromRgba(255, 245, 238, 255);
+    public static readonly Color SeaShell = FromPixel(new Rgba32(255, 245, 238, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #A0522D.
     /// </summary>
-    public static readonly Color Sienna = FromRgba(160, 82, 45, 255);
+    public static readonly Color Sienna = FromPixel(new Rgba32(160, 82, 45, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #C0C0C0.
     /// </summary>
-    public static readonly Color Silver = FromRgba(192, 192, 192, 255);
+    public static readonly Color Silver = FromPixel(new Rgba32(192, 192, 192, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #87CEEB.
     /// </summary>
-    public static readonly Color SkyBlue = FromRgba(135, 206, 235, 255);
+    public static readonly Color SkyBlue = FromPixel(new Rgba32(135, 206, 235, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #6A5ACD.
     /// </summary>
-    public static readonly Color SlateBlue = FromRgba(106, 90, 205, 255);
+    public static readonly Color SlateBlue = FromPixel(new Rgba32(106, 90, 205, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #708090.
     /// </summary>
-    public static readonly Color SlateGray = FromRgba(112, 128, 144, 255);
+    public static readonly Color SlateGray = FromPixel(new Rgba32(112, 128, 144, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #708090.
@@ -684,81 +686,80 @@ public readonly partial struct Color
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #FFFAFA.
     /// </summary>
-    public static readonly Color Snow = FromRgba(255, 250, 250, 255);
+    public static readonly Color Snow = FromPixel(new Rgba32(255, 250, 250, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #00FF7F.
     /// </summary>
-    public static readonly Color SpringGreen = FromRgba(0, 255, 127, 255);
+    public static readonly Color SpringGreen = FromPixel(new Rgba32(0, 255, 127, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #4682B4.
     /// </summary>
-    public static readonly Color SteelBlue = FromRgba(70, 130, 180, 255);
+    public static readonly Color SteelBlue = FromPixel(new Rgba32(70, 130, 180, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #D2B48C.
     /// </summary>
-    public static readonly Color Tan = FromRgba(210, 180, 140, 255);
+    public static readonly Color Tan = FromPixel(new Rgba32(210, 180, 140, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #008080.
     /// </summary>
-    public static readonly Color Teal = FromRgba(0, 128, 128, 255);
+    public static readonly Color Teal = FromPixel(new Rgba32(0, 128, 128, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #D8BFD8.
     /// </summary>
-    public static readonly Color Thistle = FromRgba(216, 191, 216, 255);
+    public static readonly Color Thistle = FromPixel(new Rgba32(216, 191, 216, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #FF6347.
     /// </summary>
-    public static readonly Color Tomato = FromRgba(255, 99, 71, 255);
+    public static readonly Color Tomato = FromPixel(new Rgba32(255, 99, 71, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #00000000.
     /// </summary>
-    public static readonly Color Transparent = FromRgba(0, 0, 0, 0);
+    public static readonly Color Transparent = FromPixel(new Rgba32(0, 0, 0, 0));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #40E0D0.
     /// </summary>
-    public static readonly Color Turquoise = FromRgba(64, 224, 208, 255);
+    public static readonly Color Turquoise = FromPixel(new Rgba32(64, 224, 208, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #EE82EE.
     /// </summary>
-    public static readonly Color Violet = FromRgba(238, 130, 238, 255);
+    public static readonly Color Violet = FromPixel(new Rgba32(238, 130, 238, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #F5DEB3.
     /// </summary>
-    public static readonly Color Wheat = FromRgba(245, 222, 179, 255);
+    public static readonly Color Wheat = FromPixel(new Rgba32(245, 222, 179, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #FFFFFF.
     /// </summary>
-    public static readonly Color White = FromRgba(255, 255, 255, 255);
+    public static readonly Color White = FromPixel(new Rgba32(255, 255, 255, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #F5F5F5.
     /// </summary>
-    public static readonly Color WhiteSmoke = FromRgba(245, 245, 245, 255);
+    public static readonly Color WhiteSmoke = FromPixel(new Rgba32(245, 245, 245, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #FFFF00.
     /// </summary>
-    public static readonly Color Yellow = FromRgba(255, 255, 0, 255);
+    public static readonly Color Yellow = FromPixel(new Rgba32(255, 255, 0, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #9ACD32.
     /// </summary>
-    public static readonly Color YellowGreen = FromRgba(154, 205, 50, 255);
+    public static readonly Color YellowGreen = FromPixel(new Rgba32(154, 205, 50, 255));
 
     private static Dictionary<string, Color> CreateNamedColorsLookup()
-    {
-        return new Dictionary<string, Color>(StringComparer.OrdinalIgnoreCase)
+        => new(StringComparer.OrdinalIgnoreCase)
         {
             { nameof(AliceBlue), AliceBlue },
             { nameof(AntiqueWhite), AntiqueWhite },
@@ -910,5 +911,4 @@ public readonly partial struct Color
             { nameof(Yellow), Yellow },
             { nameof(YellowGreen), YellowGreen }
         };
-    }
 }
diff --git a/src/ImageSharp/Color/Color.cs b/src/ImageSharp/Color/Color.cs
index cebceabe0..82ecab390 100644
--- a/src/ImageSharp/Color/Color.cs
+++ b/src/ImageSharp/Color/Color.cs
@@ -18,33 +18,24 @@ namespace SixLabors.ImageSharp;
 /// </remarks>
 public readonly partial struct Color : IEquatable<Color>
 {
-    private readonly Rgba64 data;
+    private readonly Vector4 data;
     private readonly IPixel? boxedHighPrecisionPixel;
 
+    /// <summary>
+    /// Initializes a new instance of the <see cref="Color"/> struct.
+    /// </summary>
+    /// <param name="vector">The <see cref="Vector4"/> containing the color information.</param>
     [MethodImpl(InliningOptions.ShortMethod)]
-    private Color(byte r, byte g, byte b, byte a)
-    {
-        this.data = new Rgba64(
-            ColorNumerics.UpscaleFrom8BitTo16Bit(r),
-            ColorNumerics.UpscaleFrom8BitTo16Bit(g),
-            ColorNumerics.UpscaleFrom8BitTo16Bit(b),
-            ColorNumerics.UpscaleFrom8BitTo16Bit(a));
-
-        this.boxedHighPrecisionPixel = null;
-    }
-
-    [MethodImpl(InliningOptions.ShortMethod)]
-    private Color(byte r, byte g, byte b)
+    private Color(Vector4 vector)
     {
-        this.data = new Rgba64(
-            ColorNumerics.UpscaleFrom8BitTo16Bit(r),
-            ColorNumerics.UpscaleFrom8BitTo16Bit(g),
-            ColorNumerics.UpscaleFrom8BitTo16Bit(b),
-            ushort.MaxValue);
-
+        this.data = Numerics.Clamp(vector, Vector4.Zero, Vector4.One);
         this.boxedHighPrecisionPixel = null;
     }
 
+    /// <summary>
+    /// Initializes a new instance of the <see cref="Color"/> struct.
+    /// </summary>
+    /// <param name="pixel">The pixel containing color information.</param>
     [MethodImpl(InliningOptions.ShortMethod)]
     private Color(IPixel pixel)
     {
@@ -52,6 +43,21 @@ public readonly partial struct Color : IEquatable<Color>
         this.data = default;
     }
 
+    /// <summary>
+    /// Converts a <see cref="Color"/> to <see cref="Vector4"/>.
+    /// </summary>
+    /// <param name="color">The <see cref="Color"/>.</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    public static explicit operator Vector4(Color color) => color.ToScaledVector4();
+
+    /// <summary>
+    /// Converts an <see cref="Vector4"/> to <see cref="Color"/>.
+    /// </summary>
+    /// <param name="source">The <see cref="Vector4"/>.</param>
+    /// <returns>The <see cref="Color"/>.</returns>
+    [MethodImpl(InliningOptions.ShortMethod)]
+    public static explicit operator Color(Vector4 source) => new(source);
+
     /// <summary>
     /// Checks whether two <see cref="Color"/> structures are equal.
     /// </summary>
@@ -76,27 +82,6 @@ public readonly partial struct Color : IEquatable<Color>
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(Color left, Color right) => !left.Equals(right);
 
-    /// <summary>
-    /// Creates a <see cref="Color"/> from RGBA bytes.
-    /// </summary>
-    /// <param name="r">The red component (0-255).</param>
-    /// <param name="g">The green component (0-255).</param>
-    /// <param name="b">The blue component (0-255).</param>
-    /// <param name="a">The alpha component (0-255).</param>
-    /// <returns>The <see cref="Color"/>.</returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public static Color FromRgba(byte r, byte g, byte b, byte a) => new(r, g, b, a);
-
-    /// <summary>
-    /// Creates a <see cref="Color"/> from RGB bytes.
-    /// </summary>
-    /// <param name="r">The red component (0-255).</param>
-    /// <param name="g">The green component (0-255).</param>
-    /// <param name="b">The blue component (0-255).</param>
-    /// <returns>The <see cref="Color"/>.</returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public static Color FromRgb(byte r, byte g, byte b) => new(r, g, b);
-
     /// <summary>
     /// Creates a <see cref="Color"/> from the given <typeparamref name="TPixel"/>.
     /// </summary>
@@ -107,32 +92,43 @@ public readonly partial struct Color : IEquatable<Color>
     public static Color FromPixel<TPixel>(TPixel pixel)
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        // Avoid boxing in case we can convert to Rgba64 safely and efficently
-        if (typeof(TPixel) == typeof(Rgba64))
-        {
-            return new((Rgba64)(object)pixel);
-        }
-        else if (typeof(TPixel) == typeof(Rgb48))
-        {
-            return new((Rgb48)(object)pixel);
-        }
-        else if (typeof(TPixel) == typeof(La32))
-        {
-            return new((La32)(object)pixel);
-        }
-        else if (typeof(TPixel) == typeof(L16))
+        // Avoid boxing in case we can convert to Vector4 safely and efficiently
+        PixelTypeInfo info = TPixel.GetPixelTypeInfo();
+        if (info.ComponentInfo.HasValue && info.ComponentInfo.Value.GetMaximumComponentPrecision() <= (int)PixelComponentBitDepth.Bit32)
         {
-            return new((L16)(object)pixel);
+            return new(pixel.ToScaledVector4());
         }
-        else if (Unsafe.SizeOf<TPixel>() <= Unsafe.SizeOf<Rgba32>())
+
+        return new(pixel);
+    }
+
+    /// <summary>
+    /// Bulk converts a span of a specified <typeparamref name="TPixel"/> type to a span of <see cref="Color"/>.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel type to convert to.</typeparam>
+    /// <param name="source">The source pixel span.</param>
+    /// <param name="destination">The destination color span.</param>
+    [MethodImpl(InliningOptions.ShortMethod)]
+    public static void FromPixel<TPixel>(ReadOnlySpan<TPixel> source, Span<Color> destination)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
+
+        // Avoid boxing in case we can convert to Vector4 safely and efficiently
+        PixelTypeInfo info = TPixel.GetPixelTypeInfo();
+        if (info.ComponentInfo.HasValue && info.ComponentInfo.Value.GetMaximumComponentPrecision() <= (int)PixelComponentBitDepth.Bit32)
         {
-            Rgba32 p = default;
-            pixel.ToRgba32(ref p);
-            return new(p);
+            for (int i = 0; i < destination.Length; i++)
+            {
+                destination[i] = new(source[i].ToScaledVector4());
+            }
         }
         else
         {
-            return new(pixel);
+            for (int i = 0; i < destination.Length; i++)
+            {
+                destination[i] = new(source[i]);
+            }
         }
     }
 
@@ -151,8 +147,7 @@ public readonly partial struct Color : IEquatable<Color>
     public static Color ParseHex(string hex)
     {
         Rgba32 rgba = Rgba32.ParseHex(hex);
-
-        return new Color(rgba);
+        return FromPixel(rgba);
     }
 
     /// <summary>
@@ -174,7 +169,7 @@ public readonly partial struct Color : IEquatable<Color>
 
         if (Rgba32.TryParseHex(hex, out Rgba32 rgba))
         {
-            result = new Color(rgba);
+            result = FromPixel(rgba);
             return true;
         }
 
@@ -255,12 +250,10 @@ public readonly partial struct Color : IEquatable<Color>
     {
         if (this.boxedHighPrecisionPixel is not null)
         {
-            Rgba32 rgba = default;
-            this.boxedHighPrecisionPixel.ToRgba32(ref rgba);
-            return rgba.ToHex();
+            return this.boxedHighPrecisionPixel.ToRgba32().ToHex();
         }
 
-        return this.data.ToRgba32().ToHex();
+        return Rgba32.FromScaledVector4(this.data).ToHex();
     }
 
     /// <inheritdoc />
@@ -282,14 +275,10 @@ public readonly partial struct Color : IEquatable<Color>
 
         if (this.boxedHighPrecisionPixel is null)
         {
-            pixel = default;
-            pixel.FromRgba64(this.data);
-            return pixel;
+            return TPixel.FromScaledVector4(this.data);
         }
 
-        pixel = default;
-        pixel.FromScaledVector4(this.boxedHighPrecisionPixel.ToScaledVector4());
-        return pixel;
+        return TPixel.FromScaledVector4(this.boxedHighPrecisionPixel.ToScaledVector4());
     }
 
     /// <summary>
@@ -302,7 +291,8 @@ public readonly partial struct Color : IEquatable<Color>
     public static void ToPixel<TPixel>(ReadOnlySpan<Color> source, Span<TPixel> destination)
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        // TODO: Investigate bulk operations utilizing configuration parameter here.
+        // We cannot use bulk pixel operations here as there is no guarantee that the source colors are
+        // created from pixel formats which fit into the unboxed vector data.
         Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
         for (int i = 0; i < source.Length; i++)
         {
@@ -316,7 +306,7 @@ public readonly partial struct Color : IEquatable<Color>
     {
         if (this.boxedHighPrecisionPixel is null && other.boxedHighPrecisionPixel is null)
         {
-            return this.data.PackedValue == other.data.PackedValue;
+            return this.data == other.data;
         }
 
         return this.boxedHighPrecisionPixel?.Equals(other.boxedHighPrecisionPixel) == true;
@@ -331,9 +321,20 @@ public readonly partial struct Color : IEquatable<Color>
     {
         if (this.boxedHighPrecisionPixel is null)
         {
-            return this.data.PackedValue.GetHashCode();
+            return this.data.GetHashCode();
         }
 
         return this.boxedHighPrecisionPixel.GetHashCode();
     }
+
+    [MethodImpl(InliningOptions.ShortMethod)]
+    private Vector4 ToScaledVector4()
+    {
+        if (this.boxedHighPrecisionPixel is null)
+        {
+            return this.data;
+        }
+
+        return this.boxedHighPrecisionPixel.ToScaledVector4();
+    }
 }
diff --git a/src/ImageSharp/Common/Helpers/ColorNumerics.cs b/src/ImageSharp/Common/Helpers/ColorNumerics.cs
index 553a7c2e8..1c30d857f 100644
--- a/src/ImageSharp/Common/Helpers/ColorNumerics.cs
+++ b/src/ImageSharp/Common/Helpers/ColorNumerics.cs
@@ -41,6 +41,34 @@ internal static class ColorNumerics
     public static byte Get8BitBT709Luminance(byte r, byte g, byte b)
         => (byte)((r * .2126F) + (g * .7152F) + (b * .0722F) + 0.5F);
 
+    /// <summary>
+    /// Gets the luminance from the rgb components using the formula
+    /// as specified by ITU-R Recommendation BT.709.
+    /// </summary>
+    /// <param name="r">The red component.</param>
+    /// <param name="g">The green component.</param>
+    /// <param name="b">The blue component.</param>
+    /// <returns>The <see cref="byte"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static byte Get8BitBT709Luminance(ushort r, ushort g, ushort b)
+        => (byte)((From16BitTo8Bit(r) * .2126F) +
+                  (From16BitTo8Bit(g) * .7152F) +
+                  (From16BitTo8Bit(b) * .0722F) + 0.5F);
+
+    /// <summary>
+    /// Gets the luminance from the rgb components using the formula as
+    /// specified by ITU-R Recommendation BT.709.
+    /// </summary>
+    /// <param name="r">The red component.</param>
+    /// <param name="g">The green component.</param>
+    /// <param name="b">The blue component.</param>
+    /// <returns>The <see cref="ushort"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static ushort Get16BitBT709Luminance(byte r, byte g, byte b)
+        => (ushort)((From8BitTo16Bit(r) * .2126F) +
+                    (From8BitTo16Bit(g) * .7152F) +
+                    (From8BitTo16Bit(b) * .0722F) + 0.5F);
+
     /// <summary>
     /// Gets the luminance from the rgb components using the formula as
     /// specified by ITU-R Recommendation BT.709.
@@ -72,8 +100,8 @@ internal static class ColorNumerics
     /// <param name="component">The 8 bit component value.</param>
     /// <returns>The <see cref="byte"/></returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static byte DownScaleFrom16BitTo8Bit(ushort component)
-    {
+    public static byte From16BitTo8Bit(ushort component) =>
+
         // To scale to 8 bits From a 16-bit value V the required value (from the PNG specification) is:
         //
         //    (V * 255) / 65535
@@ -102,8 +130,7 @@ internal static class ColorNumerics
         // An alternative arithmetic calculation which also gives no errors is:
         //
         //    (V * 255 + 32895) >> 16
-        return (byte)(((component * 255) + 32895) >> 16);
-    }
+        (byte)(((component * 255) + 32895) >> 16);
 
     /// <summary>
     /// Scales a value from an 8 bit <see cref="byte"/> to
@@ -112,7 +139,7 @@ internal static class ColorNumerics
     /// <param name="component">The 8 bit component value.</param>
     /// <returns>The <see cref="ushort"/></returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static ushort UpscaleFrom8BitTo16Bit(byte component)
+    public static ushort From8BitTo16Bit(byte component)
         => (ushort)(component * 257);
 
     /// <summary>
diff --git a/src/ImageSharp/Common/Helpers/Numerics.cs b/src/ImageSharp/Common/Helpers/Numerics.cs
index 293997c4d..ca28a7aab 100644
--- a/src/ImageSharp/Common/Helpers/Numerics.cs
+++ b/src/ImageSharp/Common/Helpers/Numerics.cs
@@ -5,7 +5,6 @@ using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
-using System.Runtime.Intrinsics.Arm;
 using System.Runtime.Intrinsics.X86;
 
 namespace SixLabors.ImageSharp;
@@ -61,6 +60,12 @@ internal static class Numerics
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static nint Modulo4(nint x) => x & 3;
 
+    /// <summary>
+    /// Calculates <paramref name="x"/> % 4
+    /// </summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static nuint Modulo4(nuint x) => x & 3;
+
     /// <summary>
     /// Calculates <paramref name="x"/> % 8
     /// </summary>
diff --git a/src/ImageSharp/Common/Helpers/Shuffle/IComponentShuffle.cs b/src/ImageSharp/Common/Helpers/Shuffle/IComponentShuffle.cs
index 683ac518b..c856267db 100644
--- a/src/ImageSharp/Common/Helpers/Shuffle/IComponentShuffle.cs
+++ b/src/ImageSharp/Common/Helpers/Shuffle/IComponentShuffle.cs
@@ -1,12 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System.Buffers.Binary;
-using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-using static SixLabors.ImageSharp.SimdUtils;
-
 // The JIT can detect and optimize rotation idioms ROTL (Rotate Left)
 // and ROTR (Rotate Right) emitting efficient CPU instructions:
 // https://github.com/dotnet/coreclr/pull/1830
@@ -19,190 +13,24 @@ namespace SixLabors.ImageSharp;
 internal interface IComponentShuffle
 {
     /// <summary>
-    /// Shuffles then slices 8-bit integers within 128-bit lanes in <paramref name="source"/>
-    /// using the control and store the results in <paramref name="dest"/>.
+    /// Shuffles then slices 8-bit integers in <paramref name="source"/>
+    /// using a byte control and store the results in <paramref name="destination"/>.
+    /// If successful, this method will reduce the length of <paramref name="source"/> length
+    /// by the shuffle amount.
     /// </summary>
     /// <param name="source">The source span of bytes.</param>
-    /// <param name="dest">The destination span of bytes.</param>
-    void ShuffleReduce(ref ReadOnlySpan<byte> source, ref Span<byte> dest);
+    /// <param name="destination">The destination span of bytes.</param>
+    void ShuffleReduce(ref ReadOnlySpan<byte> source, ref Span<byte> destination);
 
     /// <summary>
-    /// Shuffle 8-bit integers within 128-bit lanes in <paramref name="source"/>
-    /// using the control and store the results in <paramref name="dest"/>.
+    /// Shuffle 8-bit integers in <paramref name="source"/>
+    /// using the control and store the results in <paramref name="destination"/>.
     /// </summary>
     /// <param name="source">The source span of bytes.</param>
-    /// <param name="dest">The destination span of bytes.</param>
+    /// <param name="destination">The destination span of bytes.</param>
     /// <remarks>
-    /// Implementation can assume that source.Length is less or equal than dest.Length.
+    /// Implementation can assume that source.Length is less or equal than destination.Length.
     /// Loops should iterate using source.Length.
     /// </remarks>
-    void RunFallbackShuffle(ReadOnlySpan<byte> source, Span<byte> dest);
-}
-
-/// <inheritdoc/>
-internal interface IShuffle4 : IComponentShuffle
-{
-}
-
-internal readonly struct DefaultShuffle4 : IShuffle4
-{
-    public DefaultShuffle4(byte control)
-        => this.Control = control;
-
-    public byte Control { get; }
-
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void ShuffleReduce(ref ReadOnlySpan<byte> source, ref Span<byte> dest)
-        => HwIntrinsics.Shuffle4Reduce(ref source, ref dest, this.Control);
-
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void RunFallbackShuffle(ReadOnlySpan<byte> source, Span<byte> dest)
-    {
-        ref byte sBase = ref MemoryMarshal.GetReference(source);
-        ref byte dBase = ref MemoryMarshal.GetReference(dest);
-
-        Shuffle.InverseMMShuffle(this.Control, out uint p3, out uint p2, out uint p1, out uint p0);
-
-        for (nuint i = 0; i < (uint)source.Length; i += 4)
-        {
-            Unsafe.Add(ref dBase, i + 0) = Unsafe.Add(ref sBase, p0 + i);
-            Unsafe.Add(ref dBase, i + 1) = Unsafe.Add(ref sBase, p1 + i);
-            Unsafe.Add(ref dBase, i + 2) = Unsafe.Add(ref sBase, p2 + i);
-            Unsafe.Add(ref dBase, i + 3) = Unsafe.Add(ref sBase, p3 + i);
-        }
-    }
-}
-
-internal readonly struct WXYZShuffle4 : IShuffle4
-{
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void ShuffleReduce(ref ReadOnlySpan<byte> source, ref Span<byte> dest)
-        => HwIntrinsics.Shuffle4Reduce(ref source, ref dest, Shuffle.MMShuffle2103);
-
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void RunFallbackShuffle(ReadOnlySpan<byte> source, Span<byte> dest)
-    {
-        ref uint sBase = ref Unsafe.As<byte, uint>(ref MemoryMarshal.GetReference(source));
-        ref uint dBase = ref Unsafe.As<byte, uint>(ref MemoryMarshal.GetReference(dest));
-        uint n = (uint)source.Length / 4;
-
-        for (nuint i = 0; i < n; i++)
-        {
-            uint packed = Unsafe.Add(ref sBase, i);
-
-            // packed          = [W Z Y X]
-            // ROTL(8, packed) = [Z Y X W]
-            Unsafe.Add(ref dBase, i) = (packed << 8) | (packed >> 24);
-        }
-    }
-}
-
-internal readonly struct WZYXShuffle4 : IShuffle4
-{
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void ShuffleReduce(ref ReadOnlySpan<byte> source, ref Span<byte> dest)
-        => HwIntrinsics.Shuffle4Reduce(ref source, ref dest, Shuffle.MMShuffle0123);
-
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void RunFallbackShuffle(ReadOnlySpan<byte> source, Span<byte> dest)
-    {
-        ref uint sBase = ref Unsafe.As<byte, uint>(ref MemoryMarshal.GetReference(source));
-        ref uint dBase = ref Unsafe.As<byte, uint>(ref MemoryMarshal.GetReference(dest));
-        uint n = (uint)source.Length / 4;
-
-        for (nuint i = 0; i < n; i++)
-        {
-            uint packed = Unsafe.Add(ref sBase, i);
-
-            // packed              = [W Z Y X]
-            // REVERSE(packedArgb) = [X Y Z W]
-            Unsafe.Add(ref dBase, i) = BinaryPrimitives.ReverseEndianness(packed);
-        }
-    }
-}
-
-internal readonly struct YZWXShuffle4 : IShuffle4
-{
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void ShuffleReduce(ref ReadOnlySpan<byte> source, ref Span<byte> dest)
-        => HwIntrinsics.Shuffle4Reduce(ref source, ref dest, Shuffle.MMShuffle0321);
-
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void RunFallbackShuffle(ReadOnlySpan<byte> source, Span<byte> dest)
-    {
-        ref uint sBase = ref Unsafe.As<byte, uint>(ref MemoryMarshal.GetReference(source));
-        ref uint dBase = ref Unsafe.As<byte, uint>(ref MemoryMarshal.GetReference(dest));
-        uint n = (uint)source.Length / 4;
-
-        for (nuint i = 0; i < n; i++)
-        {
-            uint packed = Unsafe.Add(ref sBase, i);
-
-            // packed              = [W Z Y X]
-            // ROTR(8, packedArgb) = [Y Z W X]
-            Unsafe.Add(ref dBase, i) = BitOperations.RotateRight(packed, 8);
-        }
-    }
-}
-
-internal readonly struct ZYXWShuffle4 : IShuffle4
-{
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void ShuffleReduce(ref ReadOnlySpan<byte> source, ref Span<byte> dest)
-        => HwIntrinsics.Shuffle4Reduce(ref source, ref dest, Shuffle.MMShuffle3012);
-
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void RunFallbackShuffle(ReadOnlySpan<byte> source, Span<byte> dest)
-    {
-        ref uint sBase = ref Unsafe.As<byte, uint>(ref MemoryMarshal.GetReference(source));
-        ref uint dBase = ref Unsafe.As<byte, uint>(ref MemoryMarshal.GetReference(dest));
-        uint n = (uint)source.Length / 4;
-
-        for (nuint i = 0; i < n; i++)
-        {
-            uint packed = Unsafe.Add(ref sBase, i);
-
-            // packed              = [W Z Y X]
-            // tmp1                = [W 0 Y 0]
-            // tmp2                = [0 Z 0 X]
-            // tmp3=ROTL(16, tmp2) = [0 X 0 Z]
-            // tmp1 + tmp3         = [W X Y Z]
-            uint tmp1 = packed & 0xFF00FF00;
-            uint tmp2 = packed & 0x00FF00FF;
-            uint tmp3 = BitOperations.RotateLeft(tmp2, 16);
-
-            Unsafe.Add(ref dBase, i) = tmp1 + tmp3;
-        }
-    }
-}
-
-internal readonly struct XWZYShuffle4 : IShuffle4
-{
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void ShuffleReduce(ref ReadOnlySpan<byte> source, ref Span<byte> dest)
-        => HwIntrinsics.Shuffle4Reduce(ref source, ref dest, Shuffle.MMShuffle1230);
-
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void RunFallbackShuffle(ReadOnlySpan<byte> source, Span<byte> dest)
-    {
-        ref uint sBase = ref Unsafe.As<byte, uint>(ref MemoryMarshal.GetReference(source));
-        ref uint dBase = ref Unsafe.As<byte, uint>(ref MemoryMarshal.GetReference(dest));
-        uint n = (uint)source.Length / 4;
-
-        for (nuint i = 0; i < n; i++)
-        {
-            uint packed = Unsafe.Add(ref sBase, i);
-
-            // packed              = [W Z Y X]
-            // tmp1                = [0 Z 0 X]
-            // tmp2                = [W 0 Y 0]
-            // tmp3=ROTL(16, tmp2) = [Y 0 W 0]
-            // tmp1 + tmp3         = [Y Z W X]
-            uint tmp1 = packed & 0x00FF00FF;
-            uint tmp2 = packed & 0xFF00FF00;
-            uint tmp3 = BitOperations.RotateLeft(tmp2, 16);
-
-            Unsafe.Add(ref dBase, i) = tmp1 + tmp3;
-        }
-    }
+    void Shuffle(ReadOnlySpan<byte> source, Span<byte> destination);
 }
diff --git a/src/ImageSharp/Common/Helpers/Shuffle/IPad3Shuffle4.cs b/src/ImageSharp/Common/Helpers/Shuffle/IPad3Shuffle4.cs
index 6cf6eef08..0f282c7f9 100644
--- a/src/ImageSharp/Common/Helpers/Shuffle/IPad3Shuffle4.cs
+++ b/src/ImageSharp/Common/Helpers/Shuffle/IPad3Shuffle4.cs
@@ -1,6 +1,7 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using static SixLabors.ImageSharp.SimdUtils;
@@ -12,24 +13,23 @@ internal interface IPad3Shuffle4 : IComponentShuffle
 {
 }
 
-internal readonly struct DefaultPad3Shuffle4 : IPad3Shuffle4
+internal readonly struct DefaultPad3Shuffle4([ConstantExpected] byte control) : IPad3Shuffle4
 {
-    public DefaultPad3Shuffle4(byte control)
-        => this.Control = control;
-
-    public byte Control { get; }
+    public byte Control { get; } = control;
 
     [MethodImpl(InliningOptions.ShortMethod)]
-    public void ShuffleReduce(ref ReadOnlySpan<byte> source, ref Span<byte> dest)
-        => HwIntrinsics.Pad3Shuffle4Reduce(ref source, ref dest, this.Control);
+    public void ShuffleReduce(ref ReadOnlySpan<byte> source, ref Span<byte> destination)
+#pragma warning disable CA1857 // A constant is expected for the parameter
+        => HwIntrinsics.Pad3Shuffle4Reduce(ref source, ref destination, this.Control);
+#pragma warning restore CA1857 // A constant is expected for the parameter
 
     [MethodImpl(InliningOptions.ShortMethod)]
-    public void RunFallbackShuffle(ReadOnlySpan<byte> source, Span<byte> dest)
+    public void Shuffle(ReadOnlySpan<byte> source, Span<byte> destination)
     {
         ref byte sBase = ref MemoryMarshal.GetReference(source);
-        ref byte dBase = ref MemoryMarshal.GetReference(dest);
+        ref byte dBase = ref MemoryMarshal.GetReference(destination);
 
-        Shuffle.InverseMMShuffle(this.Control, out uint p3, out uint p2, out uint p1, out uint p0);
+        SimdUtils.Shuffle.InverseMMShuffle(this.Control, out uint p3, out uint p2, out uint p1, out uint p0);
 
         Span<byte> temp = stackalloc byte[4];
         ref byte t = ref MemoryMarshal.GetReference(temp);
@@ -51,14 +51,14 @@ internal readonly struct DefaultPad3Shuffle4 : IPad3Shuffle4
 internal readonly struct XYZWPad3Shuffle4 : IPad3Shuffle4
 {
     [MethodImpl(InliningOptions.ShortMethod)]
-    public void ShuffleReduce(ref ReadOnlySpan<byte> source, ref Span<byte> dest)
-        => HwIntrinsics.Pad3Shuffle4Reduce(ref source, ref dest, Shuffle.MMShuffle3210);
+    public void ShuffleReduce(ref ReadOnlySpan<byte> source, ref Span<byte> destination)
+        => HwIntrinsics.Pad3Shuffle4Reduce(ref source, ref destination, SimdUtils.Shuffle.MMShuffle3210);
 
     [MethodImpl(InliningOptions.ShortMethod)]
-    public void RunFallbackShuffle(ReadOnlySpan<byte> source, Span<byte> dest)
+    public void Shuffle(ReadOnlySpan<byte> source, Span<byte> destination)
     {
         ref byte sBase = ref MemoryMarshal.GetReference(source);
-        ref byte dBase = ref MemoryMarshal.GetReference(dest);
+        ref byte dBase = ref MemoryMarshal.GetReference(destination);
 
         ref byte sEnd = ref Unsafe.Add(ref sBase, (uint)source.Length);
         ref byte sLoopEnd = ref Unsafe.Subtract(ref sEnd, 4);
diff --git a/src/ImageSharp/Common/Helpers/Shuffle/IShuffle3.cs b/src/ImageSharp/Common/Helpers/Shuffle/IShuffle3.cs
index 2cd586212..3c0973ad6 100644
--- a/src/ImageSharp/Common/Helpers/Shuffle/IShuffle3.cs
+++ b/src/ImageSharp/Common/Helpers/Shuffle/IShuffle3.cs
@@ -1,6 +1,7 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using static SixLabors.ImageSharp.SimdUtils;
@@ -12,24 +13,23 @@ internal interface IShuffle3 : IComponentShuffle
 {
 }
 
-internal readonly struct DefaultShuffle3 : IShuffle3
+internal readonly struct DefaultShuffle3([ConstantExpected] byte control) : IShuffle3
 {
-    public DefaultShuffle3(byte control)
-        => this.Control = control;
-
-    public byte Control { get; }
+    public byte Control { get; } = control;
 
     [MethodImpl(InliningOptions.ShortMethod)]
-    public void ShuffleReduce(ref ReadOnlySpan<byte> source, ref Span<byte> dest)
-        => HwIntrinsics.Shuffle3Reduce(ref source, ref dest, this.Control);
+    public void ShuffleReduce(ref ReadOnlySpan<byte> source, ref Span<byte> destination)
+#pragma warning disable CA1857 // A constant is expected for the parameter
+        => HwIntrinsics.Shuffle3Reduce(ref source, ref destination, this.Control);
+#pragma warning restore CA1857 // A constant is expected for the parameter
 
     [MethodImpl(InliningOptions.ShortMethod)]
-    public void RunFallbackShuffle(ReadOnlySpan<byte> source, Span<byte> dest)
+    public void Shuffle(ReadOnlySpan<byte> source, Span<byte> destination)
     {
         ref byte sBase = ref MemoryMarshal.GetReference(source);
-        ref byte dBase = ref MemoryMarshal.GetReference(dest);
+        ref byte dBase = ref MemoryMarshal.GetReference(destination);
 
-        Shuffle.InverseMMShuffle(this.Control, out _, out uint p2, out uint p1, out uint p0);
+        SimdUtils.Shuffle.InverseMMShuffle(this.Control, out _, out uint p2, out uint p1, out uint p0);
 
         for (nuint i = 0; i < (uint)source.Length; i += 3)
         {
diff --git a/src/ImageSharp/Common/Helpers/Shuffle/IShuffle4.cs b/src/ImageSharp/Common/Helpers/Shuffle/IShuffle4.cs
new file mode 100644
index 000000000..d5c6df2c8
--- /dev/null
+++ b/src/ImageSharp/Common/Helpers/Shuffle/IShuffle4.cs
@@ -0,0 +1,178 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Buffers.Binary;
+using System.Diagnostics.CodeAnalysis;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using static SixLabors.ImageSharp.SimdUtils;
+
+namespace SixLabors.ImageSharp;
+
+/// <inheritdoc/>
+internal interface IShuffle4 : IComponentShuffle
+{
+}
+
+internal readonly struct DefaultShuffle4([ConstantExpected] byte control) : IShuffle4
+{
+    public byte Control { get; } = control;
+
+    [MethodImpl(InliningOptions.ShortMethod)]
+    public void ShuffleReduce(ref ReadOnlySpan<byte> source, ref Span<byte> destination)
+#pragma warning disable CA1857 // A constant is expected for the parameter
+        => HwIntrinsics.Shuffle4Reduce(ref source, ref destination, this.Control);
+#pragma warning restore CA1857 // A constant is expected for the parameter
+
+    [MethodImpl(InliningOptions.ShortMethod)]
+    public void Shuffle(ReadOnlySpan<byte> source, Span<byte> destination)
+    {
+        ref byte sBase = ref MemoryMarshal.GetReference(source);
+        ref byte dBase = ref MemoryMarshal.GetReference(destination);
+
+        SimdUtils.Shuffle.InverseMMShuffle(this.Control, out uint p3, out uint p2, out uint p1, out uint p0);
+
+        for (nuint i = 0; i < (uint)source.Length; i += 4)
+        {
+            Unsafe.Add(ref dBase, i + 0) = Unsafe.Add(ref sBase, p0 + i);
+            Unsafe.Add(ref dBase, i + 1) = Unsafe.Add(ref sBase, p1 + i);
+            Unsafe.Add(ref dBase, i + 2) = Unsafe.Add(ref sBase, p2 + i);
+            Unsafe.Add(ref dBase, i + 3) = Unsafe.Add(ref sBase, p3 + i);
+        }
+    }
+}
+
+internal readonly struct WXYZShuffle4 : IShuffle4
+{
+    [MethodImpl(InliningOptions.ShortMethod)]
+    public void ShuffleReduce(ref ReadOnlySpan<byte> source, ref Span<byte> destination)
+        => HwIntrinsics.Shuffle4Reduce(ref source, ref destination, SimdUtils.Shuffle.MMShuffle2103);
+
+    [MethodImpl(InliningOptions.ShortMethod)]
+    public void Shuffle(ReadOnlySpan<byte> source, Span<byte> destination)
+    {
+        ref uint sBase = ref Unsafe.As<byte, uint>(ref MemoryMarshal.GetReference(source));
+        ref uint dBase = ref Unsafe.As<byte, uint>(ref MemoryMarshal.GetReference(destination));
+        uint n = (uint)source.Length / 4;
+
+        for (nuint i = 0; i < n; i++)
+        {
+            uint packed = Unsafe.Add(ref sBase, i);
+
+            // packed          = [W Z Y X]
+            // ROTL(8, packed) = [Z Y X W]
+            Unsafe.Add(ref dBase, i) = (packed << 8) | (packed >> 24);
+        }
+    }
+}
+
+internal readonly struct WZYXShuffle4 : IShuffle4
+{
+    [MethodImpl(InliningOptions.ShortMethod)]
+    public void ShuffleReduce(ref ReadOnlySpan<byte> source, ref Span<byte> destination)
+        => HwIntrinsics.Shuffle4Reduce(ref source, ref destination, SimdUtils.Shuffle.MMShuffle0123);
+
+    [MethodImpl(InliningOptions.ShortMethod)]
+    public void Shuffle(ReadOnlySpan<byte> source, Span<byte> destination)
+    {
+        ref uint sBase = ref Unsafe.As<byte, uint>(ref MemoryMarshal.GetReference(source));
+        ref uint dBase = ref Unsafe.As<byte, uint>(ref MemoryMarshal.GetReference(destination));
+        uint n = (uint)source.Length / 4;
+
+        for (nuint i = 0; i < n; i++)
+        {
+            uint packed = Unsafe.Add(ref sBase, i);
+
+            // packed              = [W Z Y X]
+            // REVERSE(packedArgb) = [X Y Z W]
+            Unsafe.Add(ref dBase, i) = BinaryPrimitives.ReverseEndianness(packed);
+        }
+    }
+}
+
+internal readonly struct YZWXShuffle4 : IShuffle4
+{
+    [MethodImpl(InliningOptions.ShortMethod)]
+    public void ShuffleReduce(ref ReadOnlySpan<byte> source, ref Span<byte> destination)
+        => HwIntrinsics.Shuffle4Reduce(ref source, ref destination, SimdUtils.Shuffle.MMShuffle0321);
+
+    [MethodImpl(InliningOptions.ShortMethod)]
+    public void Shuffle(ReadOnlySpan<byte> source, Span<byte> destination)
+    {
+        ref uint sBase = ref Unsafe.As<byte, uint>(ref MemoryMarshal.GetReference(source));
+        ref uint dBase = ref Unsafe.As<byte, uint>(ref MemoryMarshal.GetReference(destination));
+        uint n = (uint)source.Length / 4;
+
+        for (nuint i = 0; i < n; i++)
+        {
+            uint packed = Unsafe.Add(ref sBase, i);
+
+            // packed              = [W Z Y X]
+            // ROTR(8, packedArgb) = [Y Z W X]
+            Unsafe.Add(ref dBase, i) = BitOperations.RotateRight(packed, 8);
+        }
+    }
+}
+
+internal readonly struct ZYXWShuffle4 : IShuffle4
+{
+    [MethodImpl(InliningOptions.ShortMethod)]
+    public void ShuffleReduce(ref ReadOnlySpan<byte> source, ref Span<byte> destination)
+        => HwIntrinsics.Shuffle4Reduce(ref source, ref destination, SimdUtils.Shuffle.MMShuffle3012);
+
+    [MethodImpl(InliningOptions.ShortMethod)]
+    public void Shuffle(ReadOnlySpan<byte> source, Span<byte> destination)
+    {
+        ref uint sBase = ref Unsafe.As<byte, uint>(ref MemoryMarshal.GetReference(source));
+        ref uint dBase = ref Unsafe.As<byte, uint>(ref MemoryMarshal.GetReference(destination));
+        uint n = (uint)source.Length / 4;
+
+        for (nuint i = 0; i < n; i++)
+        {
+            uint packed = Unsafe.Add(ref sBase, i);
+
+            // packed              = [W Z Y X]
+            // tmp1                = [W 0 Y 0]
+            // tmp2                = [0 Z 0 X]
+            // tmp3=ROTL(16, tmp2) = [0 X 0 Z]
+            // tmp1 + tmp3         = [W X Y Z]
+            uint tmp1 = packed & 0xFF00FF00;
+            uint tmp2 = packed & 0x00FF00FF;
+            uint tmp3 = BitOperations.RotateLeft(tmp2, 16);
+
+            Unsafe.Add(ref dBase, i) = tmp1 + tmp3;
+        }
+    }
+}
+
+internal readonly struct XWZYShuffle4 : IShuffle4
+{
+    [MethodImpl(InliningOptions.ShortMethod)]
+    public void ShuffleReduce(ref ReadOnlySpan<byte> source, ref Span<byte> destination)
+        => HwIntrinsics.Shuffle4Reduce(ref source, ref destination, SimdUtils.Shuffle.MMShuffle1230);
+
+    [MethodImpl(InliningOptions.ShortMethod)]
+    public void Shuffle(ReadOnlySpan<byte> source, Span<byte> destination)
+    {
+        ref uint sBase = ref Unsafe.As<byte, uint>(ref MemoryMarshal.GetReference(source));
+        ref uint dBase = ref Unsafe.As<byte, uint>(ref MemoryMarshal.GetReference(destination));
+        uint n = (uint)source.Length / 4;
+
+        for (nuint i = 0; i < n; i++)
+        {
+            uint packed = Unsafe.Add(ref sBase, i);
+
+            // packed              = [W Z Y X]
+            // tmp1                = [0 Z 0 X]
+            // tmp2                = [W 0 Y 0]
+            // tmp3=ROTL(16, tmp2) = [Y 0 W 0]
+            // tmp1 + tmp3         = [Y Z W X]
+            uint tmp1 = packed & 0x00FF00FF;
+            uint tmp2 = packed & 0xFF00FF00;
+            uint tmp3 = BitOperations.RotateLeft(tmp2, 16);
+
+            Unsafe.Add(ref dBase, i) = tmp1 + tmp3;
+        }
+    }
+}
diff --git a/src/ImageSharp/Common/Helpers/Shuffle/IShuffle4Slice3.cs b/src/ImageSharp/Common/Helpers/Shuffle/IShuffle4Slice3.cs
index 5e82973e3..3e7e44066 100644
--- a/src/ImageSharp/Common/Helpers/Shuffle/IShuffle4Slice3.cs
+++ b/src/ImageSharp/Common/Helpers/Shuffle/IShuffle4Slice3.cs
@@ -1,6 +1,7 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using static SixLabors.ImageSharp.SimdUtils;
@@ -12,26 +13,25 @@ internal interface IShuffle4Slice3 : IComponentShuffle
 {
 }
 
-internal readonly struct DefaultShuffle4Slice3 : IShuffle4Slice3
+internal readonly struct DefaultShuffle4Slice3([ConstantExpected] byte control) : IShuffle4Slice3
 {
-    public DefaultShuffle4Slice3(byte control)
-        => this.Control = control;
-
-    public byte Control { get; }
+    public byte Control { get; } = control;
 
     [MethodImpl(InliningOptions.ShortMethod)]
-    public void ShuffleReduce(ref ReadOnlySpan<byte> source, ref Span<byte> dest)
-        => HwIntrinsics.Shuffle4Slice3Reduce(ref source, ref dest, this.Control);
+    public void ShuffleReduce(ref ReadOnlySpan<byte> source, ref Span<byte> destination)
+#pragma warning disable CA1857 // A constant is expected for the parameter
+        => HwIntrinsics.Shuffle4Slice3Reduce(ref source, ref destination, this.Control);
+#pragma warning restore CA1857 // A constant is expected for the parameter
 
     [MethodImpl(InliningOptions.ShortMethod)]
-    public void RunFallbackShuffle(ReadOnlySpan<byte> source, Span<byte> dest)
+    public void Shuffle(ReadOnlySpan<byte> source, Span<byte> destination)
     {
         ref byte sBase = ref MemoryMarshal.GetReference(source);
-        ref byte dBase = ref MemoryMarshal.GetReference(dest);
+        ref byte dBase = ref MemoryMarshal.GetReference(destination);
 
-        Shuffle.InverseMMShuffle(this.Control, out _, out uint p2, out uint p1, out uint p0);
+        SimdUtils.Shuffle.InverseMMShuffle(this.Control, out _, out uint p2, out uint p1, out uint p0);
 
-        for (nuint i = 0, j = 0; i < (uint)dest.Length; i += 3, j += 4)
+        for (nuint i = 0, j = 0; i < (uint)destination.Length; i += 3, j += 4)
         {
             Unsafe.Add(ref dBase, i + 0) = Unsafe.Add(ref sBase, p0 + j);
             Unsafe.Add(ref dBase, i + 1) = Unsafe.Add(ref sBase, p1 + j);
@@ -43,14 +43,14 @@ internal readonly struct DefaultShuffle4Slice3 : IShuffle4Slice3
 internal readonly struct XYZWShuffle4Slice3 : IShuffle4Slice3
 {
     [MethodImpl(InliningOptions.ShortMethod)]
-    public void ShuffleReduce(ref ReadOnlySpan<byte> source, ref Span<byte> dest)
-        => HwIntrinsics.Shuffle4Slice3Reduce(ref source, ref dest, Shuffle.MMShuffle3210);
+    public void ShuffleReduce(ref ReadOnlySpan<byte> source, ref Span<byte> destination)
+        => HwIntrinsics.Shuffle4Slice3Reduce(ref source, ref destination, SimdUtils.Shuffle.MMShuffle3210);
 
     [MethodImpl(InliningOptions.ShortMethod)]
-    public void RunFallbackShuffle(ReadOnlySpan<byte> source, Span<byte> dest)
+    public void Shuffle(ReadOnlySpan<byte> source, Span<byte> destination)
     {
         ref uint sBase = ref Unsafe.As<byte, uint>(ref MemoryMarshal.GetReference(source));
-        ref Byte3 dBase = ref Unsafe.As<byte, Byte3>(ref MemoryMarshal.GetReference(dest));
+        ref Byte3 dBase = ref Unsafe.As<byte, Byte3>(ref MemoryMarshal.GetReference(destination));
 
         nint n = (nint)(uint)source.Length / 4;
         nint m = Numerics.Modulo4(n);
diff --git a/src/ImageSharp/Common/Helpers/SimdUtils.HwIntrinsics.cs b/src/ImageSharp/Common/Helpers/SimdUtils.HwIntrinsics.cs
index ad079b52e..f27852a82 100644
--- a/src/ImageSharp/Common/Helpers/SimdUtils.HwIntrinsics.cs
+++ b/src/ImageSharp/Common/Helpers/SimdUtils.HwIntrinsics.cs
@@ -8,6 +8,7 @@ using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
 using System.Runtime.Intrinsics.Arm;
 using System.Runtime.Intrinsics.X86;
+using SixLabors.ImageSharp.Common.Helpers;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp;
@@ -51,22 +52,34 @@ internal static partial class SimdUtils
 
         /// <summary>
         /// Shuffle single-precision (32-bit) floating-point elements in <paramref name="source"/>
-        /// using the control and store the results in <paramref name="dest"/>.
+        /// using the control and store the results in <paramref name="destination"/>.
         /// </summary>
         /// <param name="source">The source span of floats.</param>
-        /// <param name="dest">The destination span of floats.</param>
+        /// <param name="destination">The destination span of floats.</param>
         /// <param name="control">The byte control.</param>
         [MethodImpl(InliningOptions.ShortMethod)]
         public static void Shuffle4Reduce(
             ref ReadOnlySpan<float> source,
-            ref Span<float> dest,
+            ref Span<float> destination,
             [ConstantExpected] byte control)
         {
-            if (Avx.IsSupported || Sse.IsSupported)
+            if ((Vector512.IsHardwareAccelerated && Vector512Utilities.SupportsShuffleFloat) ||
+                (Vector256.IsHardwareAccelerated && Vector256Utilities.SupportsShuffleFloat) ||
+                (Vector128.IsHardwareAccelerated && Vector128Utilities.SupportsShuffleFloat))
             {
-                int remainder = Avx.IsSupported
-                    ? Numerics.ModuloP2(source.Length, Vector256<float>.Count)
-                    : Numerics.ModuloP2(source.Length, Vector128<float>.Count);
+                int remainder = 0;
+                if (Vector512.IsHardwareAccelerated)
+                {
+                    remainder = Numerics.ModuloP2(source.Length, Vector512<float>.Count);
+                }
+                else if (Vector256.IsHardwareAccelerated)
+                {
+                    remainder = Numerics.ModuloP2(source.Length, Vector256<float>.Count);
+                }
+                else if (Vector128.IsHardwareAccelerated)
+                {
+                    remainder = Numerics.ModuloP2(source.Length, Vector128<float>.Count);
+                }
 
                 int adjustedCount = source.Length - remainder;
 
@@ -74,33 +87,45 @@ internal static partial class SimdUtils
                 {
                     Shuffle4(
                         source[..adjustedCount],
-                        dest[..adjustedCount],
+                        destination[..adjustedCount],
                         control);
 
                     source = source[adjustedCount..];
-                    dest = dest[adjustedCount..];
+                    destination = destination[adjustedCount..];
                 }
             }
         }
 
         /// <summary>
-        /// Shuffle 8-bit integers within 128-bit lanes in <paramref name="source"/>
-        /// using the control and store the results in <paramref name="dest"/>.
+        /// Shuffle 8-bit integers <paramref name="source"/>
+        /// using the control and store the results in <paramref name="destination"/>.
         /// </summary>
         /// <param name="source">The source span of bytes.</param>
-        /// <param name="dest">The destination span of bytes.</param>
+        /// <param name="destination">The destination span of bytes.</param>
         /// <param name="control">The byte control.</param>
         [MethodImpl(InliningOptions.ShortMethod)]
         public static void Shuffle4Reduce(
             ref ReadOnlySpan<byte> source,
-            ref Span<byte> dest,
-            byte control)
+            ref Span<byte> destination,
+            [ConstantExpected] byte control)
         {
-            if (Avx2.IsSupported || Ssse3.IsSupported)
+            if ((Vector512.IsHardwareAccelerated && Vector512Utilities.SupportsShuffleByte) ||
+                (Vector256.IsHardwareAccelerated && Vector256Utilities.SupportsShuffleByte) ||
+                (Vector128.IsHardwareAccelerated && Vector128Utilities.SupportsShuffleByte))
             {
-                int remainder = Avx2.IsSupported
-                    ? Numerics.ModuloP2(source.Length, Vector256<byte>.Count)
-                    : Numerics.ModuloP2(source.Length, Vector128<byte>.Count);
+                int remainder = 0;
+                if (Vector512.IsHardwareAccelerated)
+                {
+                    remainder = Numerics.ModuloP2(source.Length, Vector512<byte>.Count);
+                }
+                else if (Vector256.IsHardwareAccelerated)
+                {
+                    remainder = Numerics.ModuloP2(source.Length, Vector256<byte>.Count);
+                }
+                else if (Vector128.IsHardwareAccelerated)
+                {
+                    remainder = Numerics.ModuloP2(source.Length, Vector128<byte>.Count);
+                }
 
                 int adjustedCount = source.Length - remainder;
 
@@ -108,29 +133,29 @@ internal static partial class SimdUtils
                 {
                     Shuffle4(
                         source[..adjustedCount],
-                        dest[..adjustedCount],
+                        destination[..adjustedCount],
                         control);
 
                     source = source[adjustedCount..];
-                    dest = dest[adjustedCount..];
+                    destination = destination[adjustedCount..];
                 }
             }
         }
 
         /// <summary>
-        /// Shuffles 8-bit integer triplets within 128-bit lanes in <paramref name="source"/>
-        /// using the control and store the results in <paramref name="dest"/>.
+        /// Shuffles 8-bit integer triplets in <paramref name="source"/>
+        /// using the control and store the results in <paramref name="destination"/>.
         /// </summary>
         /// <param name="source">The source span of bytes.</param>
-        /// <param name="dest">The destination span of bytes.</param>
+        /// <param name="destination">The destination span of bytes.</param>
         /// <param name="control">The byte control.</param>
         [MethodImpl(InliningOptions.ShortMethod)]
         public static void Shuffle3Reduce(
             ref ReadOnlySpan<byte> source,
-            ref Span<byte> dest,
-            byte control)
+            ref Span<byte> destination,
+            [ConstantExpected] byte control)
         {
-            if (Ssse3.IsSupported)
+            if (Vector128.IsHardwareAccelerated && Vector128Utilities.SupportsShuffleByte && Vector128Utilities.SupportsRightAlign)
             {
                 int remainder = source.Length % (Vector128<byte>.Count * 3);
 
@@ -140,77 +165,77 @@ internal static partial class SimdUtils
                 {
                     Shuffle3(
                         source[..adjustedCount],
-                        dest[..adjustedCount],
+                        destination[..adjustedCount],
                         control);
 
                     source = source[adjustedCount..];
-                    dest = dest[adjustedCount..];
+                    destination = destination[adjustedCount..];
                 }
             }
         }
 
         /// <summary>
-        /// Pads then shuffles 8-bit integers within 128-bit lanes in <paramref name="source"/>
-        /// using the control and store the results in <paramref name="dest"/>.
+        /// Pads then shuffles 8-bit integers in <paramref name="source"/>
+        /// using the control and store the results in <paramref name="destination"/>.
         /// </summary>
         /// <param name="source">The source span of bytes.</param>
-        /// <param name="dest">The destination span of bytes.</param>
+        /// <param name="destination">The destination span of bytes.</param>
         /// <param name="control">The byte control.</param>
         [MethodImpl(InliningOptions.ShortMethod)]
         public static void Pad3Shuffle4Reduce(
             ref ReadOnlySpan<byte> source,
-            ref Span<byte> dest,
-            byte control)
+            ref Span<byte> destination,
+            [ConstantExpected] byte control)
         {
-            if (Ssse3.IsSupported)
+            if (Vector128.IsHardwareAccelerated && Vector128Utilities.SupportsShuffleByte && Vector128Utilities.SupportsShiftByte)
             {
                 int remainder = source.Length % (Vector128<byte>.Count * 3);
 
                 int sourceCount = source.Length - remainder;
-                int destCount = (int)((uint)sourceCount * 4 / 3);
+                int destinationCount = (int)((uint)sourceCount * 4 / 3);
 
                 if (sourceCount > 0)
                 {
                     Pad3Shuffle4(
                         source[..sourceCount],
-                        dest[..destCount],
+                        destination[..destinationCount],
                         control);
 
                     source = source[sourceCount..];
-                    dest = dest[destCount..];
+                    destination = destination[destinationCount..];
                 }
             }
         }
 
         /// <summary>
-        /// Shuffles then slices 8-bit integers within 128-bit lanes in <paramref name="source"/>
-        /// using the control and store the results in <paramref name="dest"/>.
+        /// Shuffles then slices 8-bit integers in <paramref name="source"/>
+        /// using the control and store the results in <paramref name="destination"/>.
         /// </summary>
         /// <param name="source">The source span of bytes.</param>
-        /// <param name="dest">The destination span of bytes.</param>
+        /// <param name="destination">The destination span of bytes.</param>
         /// <param name="control">The byte control.</param>
         [MethodImpl(InliningOptions.ShortMethod)]
         public static void Shuffle4Slice3Reduce(
             ref ReadOnlySpan<byte> source,
-            ref Span<byte> dest,
-            byte control)
+            ref Span<byte> destination,
+            [ConstantExpected] byte control)
         {
-            if (Ssse3.IsSupported)
+            if (Vector128.IsHardwareAccelerated && Vector128Utilities.SupportsShuffleByte && Vector128Utilities.SupportsShiftByte)
             {
                 int remainder = source.Length & ((Vector128<byte>.Count * 4) - 1);    // bit-hack for modulo
 
                 int sourceCount = source.Length - remainder;
-                int destCount = (int)((uint)sourceCount * 3 / 4);
+                int destinationCount = (int)((uint)sourceCount * 3 / 4);
 
                 if (sourceCount > 0)
                 {
                     Shuffle4Slice3(
                         source[..sourceCount],
-                        dest[..destCount],
+                        destination[..destinationCount],
                         control);
 
                     source = source[sourceCount..];
-                    dest = dest[destCount..];
+                    destination = destination[destinationCount..];
                 }
             }
         }
@@ -218,76 +243,90 @@ internal static partial class SimdUtils
         [MethodImpl(InliningOptions.ShortMethod)]
         private static void Shuffle4(
             ReadOnlySpan<float> source,
-            Span<float> dest,
+            Span<float> destination,
             [ConstantExpected] byte control)
         {
-            if (Avx.IsSupported)
+            if (Vector512.IsHardwareAccelerated && Vector512Utilities.SupportsShuffleFloat)
             {
-                ref Vector256<float> sourceBase =
-                    ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref Vector512<float> sourceBase = ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(source));
+                ref Vector512<float> destinationBase = ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
 
-                ref Vector256<float> destBase =
-                    ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(dest));
+                nuint n = (uint)destination.Length / (uint)Vector512<float>.Count;
+                nuint m = Numerics.Modulo4(n);
+                nuint u = n - m;
 
-                nint n = (nint)dest.Vector256Count<float>();
-                nint m = Numerics.Modulo4(n);
-                nint u = n - m;
-
-                for (nint i = 0; i < u; i += 4)
+                for (nuint i = 0; i < u; i += 4)
                 {
-                    ref Vector256<float> vd0 = ref Unsafe.Add(ref destBase, i);
-                    ref Vector256<float> vs0 = ref Unsafe.Add(ref sourceBase, i);
+                    ref Vector512<float> vs0 = ref Unsafe.Add(ref sourceBase, i);
+                    ref Vector512<float> vd0 = ref Unsafe.Add(ref destinationBase, i);
 
-                    vd0 = Avx.Permute(vs0, control);
-                    Unsafe.Add(ref vd0, 1) = Avx.Permute(Unsafe.Add(ref vs0, 1), control);
-                    Unsafe.Add(ref vd0, 2) = Avx.Permute(Unsafe.Add(ref vs0, 2), control);
-                    Unsafe.Add(ref vd0, 3) = Avx.Permute(Unsafe.Add(ref vs0, 3), control);
+                    vd0 = Vector512Utilities.Shuffle(vs0, control);
+                    Unsafe.Add(ref vd0, (nuint)1) = Vector512Utilities.Shuffle(Unsafe.Add(ref vs0, (nuint)1), control);
+                    Unsafe.Add(ref vd0, (nuint)2) = Vector512Utilities.Shuffle(Unsafe.Add(ref vs0, (nuint)2), control);
+                    Unsafe.Add(ref vd0, (nuint)3) = Vector512Utilities.Shuffle(Unsafe.Add(ref vs0, (nuint)3), control);
                 }
 
                 if (m > 0)
                 {
-                    for (nint i = u; i < n; i++)
+                    for (nuint i = u; i < n; i++)
                     {
-                        Unsafe.Add(ref destBase, i) = Avx.Permute(Unsafe.Add(ref sourceBase, i), control);
+                        Unsafe.Add(ref destinationBase, i) = Vector512Utilities.Shuffle(Unsafe.Add(ref sourceBase, i), control);
                     }
                 }
             }
-            else
+            else if (Vector256.IsHardwareAccelerated && Vector256Utilities.SupportsShuffleFloat)
             {
-                // Sse
-                ref Vector128<float> sourceBase =
-                    ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(source));
+                ref Vector256<float> sourceBase = ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+                ref Vector256<float> destinationBase = ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
 
-                ref Vector128<float> destBase =
-                    ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(dest));
+                nuint n = (uint)destination.Length / (uint)Vector256<float>.Count;
+                nuint m = Numerics.Modulo4(n);
+                nuint u = n - m;
 
-                nint n = (nint)((uint)dest.Length / (uint)Vector128<float>.Count);
-                nint m = Numerics.Modulo4(n);
-                nint u = n - m;
-
-                for (nint i = 0; i < u; i += 4)
+                for (nuint i = 0; i < u; i += 4)
                 {
-                    ref Vector128<float> vd0 = ref Unsafe.Add(ref destBase, i);
-                    ref Vector128<float> vs0 = ref Unsafe.Add(ref sourceBase, i);
+                    ref Vector256<float> vs0 = ref Unsafe.Add(ref sourceBase, i);
+                    ref Vector256<float> vd0 = ref Unsafe.Add(ref destinationBase, i);
+
+                    vd0 = Vector256Utilities.Shuffle(vs0, control);
+                    Unsafe.Add(ref vd0, (nuint)1) = Vector256Utilities.Shuffle(Unsafe.Add(ref vs0, (nuint)1), control);
+                    Unsafe.Add(ref vd0, (nuint)2) = Vector256Utilities.Shuffle(Unsafe.Add(ref vs0, (nuint)2), control);
+                    Unsafe.Add(ref vd0, (nuint)3) = Vector256Utilities.Shuffle(Unsafe.Add(ref vs0, (nuint)3), control);
+                }
 
-                    vd0 = Sse.Shuffle(vs0, vs0, control);
+                if (m > 0)
+                {
+                    for (nuint i = u; i < n; i++)
+                    {
+                        Unsafe.Add(ref destinationBase, i) = Vector256Utilities.Shuffle(Unsafe.Add(ref sourceBase, i), control);
+                    }
+                }
+            }
+            else if (Vector128.IsHardwareAccelerated && Vector128Utilities.SupportsShuffleFloat)
+            {
+                ref Vector128<float> sourceBase = ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(source));
+                ref Vector128<float> destinationBase = ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(destination));
 
-                    Vector128<float> vs1 = Unsafe.Add(ref vs0, 1);
-                    Unsafe.Add(ref vd0, 1) = Sse.Shuffle(vs1, vs1, control);
+                nuint n = (uint)destination.Length / (uint)Vector128<float>.Count;
+                nuint m = Numerics.Modulo4(n);
+                nuint u = n - m;
 
-                    Vector128<float> vs2 = Unsafe.Add(ref vs0, 2);
-                    Unsafe.Add(ref vd0, 2) = Sse.Shuffle(vs2, vs2, control);
+                for (nuint i = 0; i < u; i += 4)
+                {
+                    ref Vector128<float> vs0 = ref Unsafe.Add(ref sourceBase, i);
+                    ref Vector128<float> vd0 = ref Unsafe.Add(ref destinationBase, i);
 
-                    Vector128<float> vs3 = Unsafe.Add(ref vs0, 3);
-                    Unsafe.Add(ref vd0, 3) = Sse.Shuffle(vs3, vs3, control);
+                    vd0 = Vector128Utilities.Shuffle(vs0, control);
+                    Unsafe.Add(ref vd0, (nuint)1) = Vector128Utilities.Shuffle(Unsafe.Add(ref vs0, (nuint)1), control);
+                    Unsafe.Add(ref vd0, (nuint)2) = Vector128Utilities.Shuffle(Unsafe.Add(ref vs0, (nuint)2), control);
+                    Unsafe.Add(ref vd0, (nuint)3) = Vector128Utilities.Shuffle(Unsafe.Add(ref vs0, (nuint)3), control);
                 }
 
                 if (m > 0)
                 {
-                    for (nint i = u; i < n; i++)
+                    for (nuint i = u; i < n; i++)
                     {
-                        Vector128<float> vs = Unsafe.Add(ref sourceBase, i);
-                        Unsafe.Add(ref destBase, i) = Sse.Shuffle(vs, vs, control);
+                        Unsafe.Add(ref destinationBase, i) = Vector128Utilities.Shuffle(Unsafe.Add(ref sourceBase, i), control);
                     }
                 }
             }
@@ -296,80 +335,102 @@ internal static partial class SimdUtils
         [MethodImpl(InliningOptions.ShortMethod)]
         private static void Shuffle4(
             ReadOnlySpan<byte> source,
-            Span<byte> dest,
-            byte control)
+            Span<byte> destination,
+            [ConstantExpected] byte control)
         {
-            if (Avx2.IsSupported)
+            if (Vector512.IsHardwareAccelerated && Vector512Utilities.SupportsShuffleByte)
             {
-                // I've chosen to do this for convenience while we determine what
-                // shuffle controls to add to the library.
-                // We can add static ROS instances if need be in the future.
-                Span<byte> bytes = stackalloc byte[Vector256<byte>.Count];
-                Shuffle.MMShuffleSpan(ref bytes, control);
-                Vector256<byte> vshuffle = Unsafe.As<byte, Vector256<byte>>(ref MemoryMarshal.GetReference(bytes));
+                Span<byte> temp = stackalloc byte[Vector512<byte>.Count];
+                Shuffle.MMShuffleSpan(ref temp, control);
+                Vector512<byte> mask = Unsafe.As<byte, Vector512<byte>>(ref MemoryMarshal.GetReference(temp));
 
-                ref Vector256<byte> sourceBase =
-                    ref Unsafe.As<byte, Vector256<byte>>(ref MemoryMarshal.GetReference(source));
+                ref Vector512<byte> sourceBase = ref Unsafe.As<byte, Vector512<byte>>(ref MemoryMarshal.GetReference(source));
+                ref Vector512<byte> destinationBase = ref Unsafe.As<byte, Vector512<byte>>(ref MemoryMarshal.GetReference(destination));
 
-                ref Vector256<byte> destBase =
-                    ref Unsafe.As<byte, Vector256<byte>>(ref MemoryMarshal.GetReference(dest));
+                nuint n = (uint)destination.Length / (uint)Vector512<byte>.Count;
+                nuint m = Numerics.Modulo4(n);
+                nuint u = n - m;
+
+                for (nuint i = 0; i < u; i += 4)
+                {
+                    ref Vector512<byte> vs0 = ref Unsafe.Add(ref sourceBase, i);
+                    ref Vector512<byte> vd0 = ref Unsafe.Add(ref destinationBase, i);
+
+                    vd0 = Vector512Utilities.Shuffle(vs0, mask);
+                    Unsafe.Add(ref vd0, (nuint)1) = Vector512Utilities.Shuffle(Unsafe.Add(ref vs0, (nuint)1), mask);
+                    Unsafe.Add(ref vd0, (nuint)2) = Vector512Utilities.Shuffle(Unsafe.Add(ref vs0, (nuint)2), mask);
+                    Unsafe.Add(ref vd0, (nuint)3) = Vector512Utilities.Shuffle(Unsafe.Add(ref vs0, (nuint)3), mask);
+                }
+
+                if (m > 0)
+                {
+                    for (nuint i = u; i < n; i++)
+                    {
+                        Unsafe.Add(ref destinationBase, i) = Vector512Utilities.Shuffle(Unsafe.Add(ref sourceBase, i), mask);
+                    }
+                }
+            }
+            else if (Vector256.IsHardwareAccelerated && Vector256Utilities.SupportsShuffleByte)
+            {
+                Span<byte> temp = stackalloc byte[Vector256<byte>.Count];
+                Shuffle.MMShuffleSpan(ref temp, control);
+                Vector256<byte> mask = Unsafe.As<byte, Vector256<byte>>(ref MemoryMarshal.GetReference(temp));
+
+                ref Vector256<byte> sourceBase = ref Unsafe.As<byte, Vector256<byte>>(ref MemoryMarshal.GetReference(source));
+                ref Vector256<byte> destinationBase = ref Unsafe.As<byte, Vector256<byte>>(ref MemoryMarshal.GetReference(destination));
 
-                nint n = (nint)((uint)dest.Length / (uint)Vector256<byte>.Count);
-                nint m = Numerics.Modulo4(n);
-                nint u = n - m;
+                nuint n = (uint)destination.Length / (uint)Vector256<byte>.Count;
+                nuint m = Numerics.Modulo4(n);
+                nuint u = n - m;
 
-                for (nint i = 0; i < u; i += 4)
+                for (nuint i = 0; i < u; i += 4)
                 {
                     ref Vector256<byte> vs0 = ref Unsafe.Add(ref sourceBase, i);
-                    ref Vector256<byte> vd0 = ref Unsafe.Add(ref destBase, i);
+                    ref Vector256<byte> vd0 = ref Unsafe.Add(ref destinationBase, i);
 
-                    vd0 = Avx2.Shuffle(vs0, vshuffle);
-                    Unsafe.Add(ref vd0, 1) = Avx2.Shuffle(Unsafe.Add(ref vs0, 1), vshuffle);
-                    Unsafe.Add(ref vd0, 2) = Avx2.Shuffle(Unsafe.Add(ref vs0, 2), vshuffle);
-                    Unsafe.Add(ref vd0, 3) = Avx2.Shuffle(Unsafe.Add(ref vs0, 3), vshuffle);
+                    vd0 = Vector256Utilities.Shuffle(vs0, mask);
+                    Unsafe.Add(ref vd0, (nuint)1) = Vector256Utilities.Shuffle(Unsafe.Add(ref vs0, (nuint)1), mask);
+                    Unsafe.Add(ref vd0, (nuint)2) = Vector256Utilities.Shuffle(Unsafe.Add(ref vs0, (nuint)2), mask);
+                    Unsafe.Add(ref vd0, (nuint)3) = Vector256Utilities.Shuffle(Unsafe.Add(ref vs0, (nuint)3), mask);
                 }
 
                 if (m > 0)
                 {
-                    for (nint i = u; i < n; i++)
+                    for (nuint i = u; i < n; i++)
                     {
-                        Unsafe.Add(ref destBase, i) = Avx2.Shuffle(Unsafe.Add(ref sourceBase, i), vshuffle);
+                        Unsafe.Add(ref destinationBase, i) = Vector256Utilities.Shuffle(Unsafe.Add(ref sourceBase, i), mask);
                     }
                 }
             }
-            else
+            else if (Vector128.IsHardwareAccelerated && Vector128Utilities.SupportsShuffleByte)
             {
-                // Ssse3
-                Span<byte> bytes = stackalloc byte[Vector128<byte>.Count];
-                Shuffle.MMShuffleSpan(ref bytes, control);
-                Vector128<byte> vshuffle = Unsafe.As<byte, Vector128<byte>>(ref MemoryMarshal.GetReference(bytes));
-
-                ref Vector128<byte> sourceBase =
-                    ref Unsafe.As<byte, Vector128<byte>>(ref MemoryMarshal.GetReference(source));
+                Span<byte> temp = stackalloc byte[Vector128<byte>.Count];
+                Shuffle.MMShuffleSpan(ref temp, control);
+                Vector128<byte> mask = Unsafe.As<byte, Vector128<byte>>(ref MemoryMarshal.GetReference(temp));
 
-                ref Vector128<byte> destBase =
-                    ref Unsafe.As<byte, Vector128<byte>>(ref MemoryMarshal.GetReference(dest));
+                ref Vector128<byte> sourceBase = ref Unsafe.As<byte, Vector128<byte>>(ref MemoryMarshal.GetReference(source));
+                ref Vector128<byte> destinationBase = ref Unsafe.As<byte, Vector128<byte>>(ref MemoryMarshal.GetReference(destination));
 
-                nint n = (nint)((uint)dest.Length / (uint)Vector128<byte>.Count);
-                nint m = Numerics.Modulo4(n);
-                nint u = n - m;
+                nuint n = (uint)destination.Length / (uint)Vector128<byte>.Count;
+                nuint m = Numerics.Modulo4(n);
+                nuint u = n - m;
 
-                for (nint i = 0; i < u; i += 4)
+                for (nuint i = 0; i < u; i += 4)
                 {
                     ref Vector128<byte> vs0 = ref Unsafe.Add(ref sourceBase, i);
-                    ref Vector128<byte> vd0 = ref Unsafe.Add(ref destBase, i);
+                    ref Vector128<byte> vd0 = ref Unsafe.Add(ref destinationBase, i);
 
-                    vd0 = Ssse3.Shuffle(vs0, vshuffle);
-                    Unsafe.Add(ref vd0, 1) = Ssse3.Shuffle(Unsafe.Add(ref vs0, 1), vshuffle);
-                    Unsafe.Add(ref vd0, 2) = Ssse3.Shuffle(Unsafe.Add(ref vs0, 2), vshuffle);
-                    Unsafe.Add(ref vd0, 3) = Ssse3.Shuffle(Unsafe.Add(ref vs0, 3), vshuffle);
+                    vd0 = Vector128Utilities.Shuffle(vs0, mask);
+                    Unsafe.Add(ref vd0, (nuint)1) = Vector128Utilities.Shuffle(Unsafe.Add(ref vs0, (nuint)1), mask);
+                    Unsafe.Add(ref vd0, (nuint)2) = Vector128Utilities.Shuffle(Unsafe.Add(ref vs0, (nuint)2), mask);
+                    Unsafe.Add(ref vd0, (nuint)3) = Vector128Utilities.Shuffle(Unsafe.Add(ref vs0, (nuint)3), mask);
                 }
 
                 if (m > 0)
                 {
-                    for (nint i = u; i < n; i++)
+                    for (nuint i = u; i < n; i++)
                     {
-                        Unsafe.Add(ref destBase, i) = Ssse3.Shuffle(Unsafe.Add(ref sourceBase, i), vshuffle);
+                        Unsafe.Add(ref destinationBase, i) = Vector128Utilities.Shuffle(Unsafe.Add(ref sourceBase, i), mask);
                     }
                 }
             }
@@ -378,24 +439,21 @@ internal static partial class SimdUtils
         [MethodImpl(InliningOptions.ShortMethod)]
         private static void Shuffle3(
             ReadOnlySpan<byte> source,
-            Span<byte> dest,
-            byte control)
+            Span<byte> destination,
+            [ConstantExpected] byte control)
         {
-            if (Ssse3.IsSupported)
+            if (Vector128.IsHardwareAccelerated && Vector128Utilities.SupportsShuffleByte && Vector128Utilities.SupportsRightAlign)
             {
-                Vector128<byte> vmask = ShuffleMaskPad4Nx16();
-                Vector128<byte> vmasko = ShuffleMaskSlice4Nx16();
-                Vector128<byte> vmaske = Ssse3.AlignRight(vmasko, vmasko, 12);
+                Vector128<byte> maskPad4Nx16 = ShuffleMaskPad4Nx16();
+                Vector128<byte> maskSlice4Nx16 = ShuffleMaskSlice4Nx16();
+                Vector128<byte> maskE = Vector128Utilities.AlignRight(maskSlice4Nx16, maskSlice4Nx16, 12);
 
                 Span<byte> bytes = stackalloc byte[Vector128<byte>.Count];
                 Shuffle.MMShuffleSpan(ref bytes, control);
-                Vector128<byte> vshuffle = Unsafe.As<byte, Vector128<byte>>(ref MemoryMarshal.GetReference(bytes));
+                Vector128<byte> mask = Unsafe.As<byte, Vector128<byte>>(ref MemoryMarshal.GetReference(bytes));
 
-                ref Vector128<byte> sourceBase =
-                    ref Unsafe.As<byte, Vector128<byte>>(ref MemoryMarshal.GetReference(source));
-
-                ref Vector128<byte> destBase =
-                    ref Unsafe.As<byte, Vector128<byte>>(ref MemoryMarshal.GetReference(dest));
+                ref Vector128<byte> sourceBase = ref Unsafe.As<byte, Vector128<byte>>(ref MemoryMarshal.GetReference(source));
+                ref Vector128<byte> destinationBase = ref Unsafe.As<byte, Vector128<byte>>(ref MemoryMarshal.GetReference(destination));
 
                 nuint n = source.Vector128Count<byte>();
 
@@ -404,36 +462,36 @@ internal static partial class SimdUtils
                     ref Vector128<byte> vs = ref Unsafe.Add(ref sourceBase, i);
 
                     Vector128<byte> v0 = vs;
-                    Vector128<byte> v1 = Unsafe.Add(ref vs, 1);
-                    Vector128<byte> v2 = Unsafe.Add(ref vs, 2);
-                    Vector128<byte> v3 = Sse2.ShiftRightLogical128BitLane(v2, 4);
+                    Vector128<byte> v1 = Unsafe.Add(ref vs, (nuint)1);
+                    Vector128<byte> v2 = Unsafe.Add(ref vs, (nuint)2);
+                    Vector128<byte> v3 = Vector128Utilities.ShiftRightBytesInVector(v2, 4);
 
-                    v2 = Ssse3.AlignRight(v2, v1, 8);
-                    v1 = Ssse3.AlignRight(v1, v0, 12);
+                    v2 = Vector128Utilities.AlignRight(v2, v1, 8);
+                    v1 = Vector128Utilities.AlignRight(v1, v0, 12);
 
-                    v0 = Ssse3.Shuffle(Ssse3.Shuffle(v0, vmask), vshuffle);
-                    v1 = Ssse3.Shuffle(Ssse3.Shuffle(v1, vmask), vshuffle);
-                    v2 = Ssse3.Shuffle(Ssse3.Shuffle(v2, vmask), vshuffle);
-                    v3 = Ssse3.Shuffle(Ssse3.Shuffle(v3, vmask), vshuffle);
+                    v0 = Vector128Utilities.Shuffle(Vector128Utilities.Shuffle(v0, maskPad4Nx16), mask);
+                    v1 = Vector128Utilities.Shuffle(Vector128Utilities.Shuffle(v1, maskPad4Nx16), mask);
+                    v2 = Vector128Utilities.Shuffle(Vector128Utilities.Shuffle(v2, maskPad4Nx16), mask);
+                    v3 = Vector128Utilities.Shuffle(Vector128Utilities.Shuffle(v3, maskPad4Nx16), mask);
 
-                    v0 = Ssse3.Shuffle(v0, vmaske);
-                    v1 = Ssse3.Shuffle(v1, vmasko);
-                    v2 = Ssse3.Shuffle(v2, vmaske);
-                    v3 = Ssse3.Shuffle(v3, vmasko);
+                    v0 = Vector128Utilities.Shuffle(v0, maskE);
+                    v1 = Vector128Utilities.Shuffle(v1, maskSlice4Nx16);
+                    v2 = Vector128Utilities.Shuffle(v2, maskE);
+                    v3 = Vector128Utilities.Shuffle(v3, maskSlice4Nx16);
 
-                    v0 = Ssse3.AlignRight(v1, v0, 4);
-                    v3 = Ssse3.AlignRight(v3, v2, 12);
+                    v0 = Vector128Utilities.AlignRight(v1, v0, 4);
+                    v3 = Vector128Utilities.AlignRight(v3, v2, 12);
 
-                    v1 = Sse2.ShiftLeftLogical128BitLane(v1, 4);
-                    v2 = Sse2.ShiftRightLogical128BitLane(v2, 4);
+                    v1 = Vector128Utilities.ShiftLeftBytesInVector(v1, 4);
+                    v2 = Vector128Utilities.ShiftRightBytesInVector(v2, 4);
 
-                    v1 = Ssse3.AlignRight(v2, v1, 8);
+                    v1 = Vector128Utilities.AlignRight(v2, v1, 8);
 
-                    ref Vector128<byte> vd = ref Unsafe.Add(ref destBase, i);
+                    ref Vector128<byte> vd = ref Unsafe.Add(ref destinationBase, i);
 
                     vd = v0;
-                    Unsafe.Add(ref vd, 1) = v1;
-                    Unsafe.Add(ref vd, 2) = v3;
+                    Unsafe.Add(ref vd, (nuint)1) = v1;
+                    Unsafe.Add(ref vd, (nuint)2) = v3;
                 }
             }
         }
@@ -441,23 +499,23 @@ internal static partial class SimdUtils
         [MethodImpl(InliningOptions.ShortMethod)]
         private static void Pad3Shuffle4(
             ReadOnlySpan<byte> source,
-            Span<byte> dest,
-            byte control)
+            Span<byte> destination,
+            [ConstantExpected] byte control)
         {
-            if (Ssse3.IsSupported)
+            if (Vector128.IsHardwareAccelerated && Vector128Utilities.SupportsShuffleByte && Vector128Utilities.SupportsShiftByte)
             {
-                Vector128<byte> vmask = ShuffleMaskPad4Nx16();
-                Vector128<byte> vfill = Vector128.Create(0xff000000ff000000ul).AsByte();
+                Vector128<byte> maskPad4Nx16 = ShuffleMaskPad4Nx16();
+                Vector128<byte> fill = Vector128.Create(0xff000000ff000000ul).AsByte();
 
-                Span<byte> bytes = stackalloc byte[Vector128<byte>.Count];
-                Shuffle.MMShuffleSpan(ref bytes, control);
-                Vector128<byte> vshuffle = Unsafe.As<byte, Vector128<byte>>(ref MemoryMarshal.GetReference(bytes));
+                Span<byte> temp = stackalloc byte[Vector128<byte>.Count];
+                Shuffle.MMShuffleSpan(ref temp, control);
+                Vector128<byte> mask = Unsafe.As<byte, Vector128<byte>>(ref MemoryMarshal.GetReference(temp));
 
                 ref Vector128<byte> sourceBase =
                     ref Unsafe.As<byte, Vector128<byte>>(ref MemoryMarshal.GetReference(source));
 
-                ref Vector128<byte> destBase =
-                    ref Unsafe.As<byte, Vector128<byte>>(ref MemoryMarshal.GetReference(dest));
+                ref Vector128<byte> destinationBase =
+                    ref Unsafe.As<byte, Vector128<byte>>(ref MemoryMarshal.GetReference(destination));
 
                 nuint n = source.Vector128Count<byte>();
 
@@ -466,17 +524,17 @@ internal static partial class SimdUtils
                     ref Vector128<byte> v0 = ref Unsafe.Add(ref sourceBase, i);
                     Vector128<byte> v1 = Unsafe.Add(ref v0, 1);
                     Vector128<byte> v2 = Unsafe.Add(ref v0, 2);
-                    Vector128<byte> v3 = Sse2.ShiftRightLogical128BitLane(v2, 4);
+                    Vector128<byte> v3 = Vector128Utilities.ShiftRightBytesInVector(v2, 4);
 
-                    v2 = Ssse3.AlignRight(v2, v1, 8);
-                    v1 = Ssse3.AlignRight(v1, v0, 12);
+                    v2 = Vector128Utilities.AlignRight(v2, v1, 8);
+                    v1 = Vector128Utilities.AlignRight(v1, v0, 12);
 
-                    ref Vector128<byte> vd = ref Unsafe.Add(ref destBase, j);
+                    ref Vector128<byte> vd = ref Unsafe.Add(ref destinationBase, j);
 
-                    vd = Ssse3.Shuffle(Sse2.Or(Ssse3.Shuffle(v0, vmask), vfill), vshuffle);
-                    Unsafe.Add(ref vd, 1) = Ssse3.Shuffle(Sse2.Or(Ssse3.Shuffle(v1, vmask), vfill), vshuffle);
-                    Unsafe.Add(ref vd, 2) = Ssse3.Shuffle(Sse2.Or(Ssse3.Shuffle(v2, vmask), vfill), vshuffle);
-                    Unsafe.Add(ref vd, 3) = Ssse3.Shuffle(Sse2.Or(Ssse3.Shuffle(v3, vmask), vfill), vshuffle);
+                    vd = Vector128Utilities.Shuffle(Vector128Utilities.Shuffle(v0, maskPad4Nx16) | fill, mask);
+                    Unsafe.Add(ref vd, 1) = Vector128Utilities.Shuffle(Vector128Utilities.Shuffle(v1, maskPad4Nx16) | fill, mask);
+                    Unsafe.Add(ref vd, 2) = Vector128Utilities.Shuffle(Vector128Utilities.Shuffle(v2, maskPad4Nx16) | fill, mask);
+                    Unsafe.Add(ref vd, 3) = Vector128Utilities.Shuffle(Vector128Utilities.Shuffle(v3, maskPad4Nx16) | fill, mask);
                 }
             }
         }
@@ -484,23 +542,23 @@ internal static partial class SimdUtils
         [MethodImpl(InliningOptions.ShortMethod)]
         private static void Shuffle4Slice3(
             ReadOnlySpan<byte> source,
-            Span<byte> dest,
-            byte control)
+            Span<byte> destination,
+            [ConstantExpected] byte control)
         {
-            if (Ssse3.IsSupported)
+            if (Vector128.IsHardwareAccelerated && Vector128Utilities.SupportsShuffleByte && Vector128Utilities.SupportsShiftByte)
             {
-                Vector128<byte> vmasko = ShuffleMaskSlice4Nx16();
-                Vector128<byte> vmaske = Ssse3.AlignRight(vmasko, vmasko, 12);
+                Vector128<byte> maskSlice4Nx16 = ShuffleMaskSlice4Nx16();
+                Vector128<byte> maskE = Vector128Utilities.AlignRight(maskSlice4Nx16, maskSlice4Nx16, 12);
 
-                Span<byte> bytes = stackalloc byte[Vector128<byte>.Count];
-                Shuffle.MMShuffleSpan(ref bytes, control);
-                Vector128<byte> vshuffle = Unsafe.As<byte, Vector128<byte>>(ref MemoryMarshal.GetReference(bytes));
+                Span<byte> temp = stackalloc byte[Vector128<byte>.Count];
+                Shuffle.MMShuffleSpan(ref temp, control);
+                Vector128<byte> mask = Unsafe.As<byte, Vector128<byte>>(ref MemoryMarshal.GetReference(temp));
 
                 ref Vector128<byte> sourceBase =
                     ref Unsafe.As<byte, Vector128<byte>>(ref MemoryMarshal.GetReference(source));
 
-                ref Vector128<byte> destBase =
-                    ref Unsafe.As<byte, Vector128<byte>>(ref MemoryMarshal.GetReference(dest));
+                ref Vector128<byte> destinationBase =
+                    ref Unsafe.As<byte, Vector128<byte>>(ref MemoryMarshal.GetReference(destination));
 
                 nuint n = source.Vector128Count<byte>();
 
@@ -513,20 +571,20 @@ internal static partial class SimdUtils
                     Vector128<byte> v2 = Unsafe.Add(ref vs, 2);
                     Vector128<byte> v3 = Unsafe.Add(ref vs, 3);
 
-                    v0 = Ssse3.Shuffle(Ssse3.Shuffle(v0, vshuffle), vmaske);
-                    v1 = Ssse3.Shuffle(Ssse3.Shuffle(v1, vshuffle), vmasko);
-                    v2 = Ssse3.Shuffle(Ssse3.Shuffle(v2, vshuffle), vmaske);
-                    v3 = Ssse3.Shuffle(Ssse3.Shuffle(v3, vshuffle), vmasko);
+                    v0 = Vector128Utilities.Shuffle(Vector128Utilities.Shuffle(v0, mask), maskE);
+                    v1 = Vector128Utilities.Shuffle(Vector128Utilities.Shuffle(v1, mask), maskSlice4Nx16);
+                    v2 = Vector128Utilities.Shuffle(Vector128Utilities.Shuffle(v2, mask), maskE);
+                    v3 = Vector128Utilities.Shuffle(Vector128Utilities.Shuffle(v3, mask), maskSlice4Nx16);
 
-                    v0 = Ssse3.AlignRight(v1, v0, 4);
-                    v3 = Ssse3.AlignRight(v3, v2, 12);
+                    v0 = Vector128Utilities.AlignRight(v1, v0, 4);
+                    v3 = Vector128Utilities.AlignRight(v3, v2, 12);
 
-                    v1 = Sse2.ShiftLeftLogical128BitLane(v1, 4);
-                    v2 = Sse2.ShiftRightLogical128BitLane(v2, 4);
+                    v1 = Vector128Utilities.ShiftLeftBytesInVector(v1, 4);
+                    v2 = Vector128Utilities.ShiftRightBytesInVector(v2, 4);
 
-                    v1 = Ssse3.AlignRight(v2, v1, 8);
+                    v1 = Vector128Utilities.AlignRight(v2, v1, 8);
 
-                    ref Vector128<byte> vd = ref Unsafe.Add(ref destBase, j);
+                    ref Vector128<byte> vd = ref Unsafe.Add(ref destinationBase, j);
 
                     vd = v0;
                     Unsafe.Add(ref vd, 1) = v1;
diff --git a/src/ImageSharp/Common/Helpers/SimdUtils.Shuffle.cs b/src/ImageSharp/Common/Helpers/SimdUtils.Shuffle.cs
index 83cd3d246..dbeb54a80 100644
--- a/src/ImageSharp/Common/Helpers/SimdUtils.Shuffle.cs
+++ b/src/ImageSharp/Common/Helpers/SimdUtils.Shuffle.cs
@@ -12,140 +12,140 @@ internal static partial class SimdUtils
 {
     /// <summary>
     /// Shuffle single-precision (32-bit) floating-point elements in <paramref name="source"/>
-    /// using the control and store the results in <paramref name="dest"/>.
+    /// using the control and store the results in <paramref name="destination"/>.
     /// </summary>
     /// <param name="source">The source span of floats.</param>
-    /// <param name="dest">The destination span of floats.</param>
+    /// <param name="destination">The destination span of floats.</param>
     /// <param name="control">The byte control.</param>
     [MethodImpl(InliningOptions.ShortMethod)]
     public static void Shuffle4(
         ReadOnlySpan<float> source,
-        Span<float> dest,
+        Span<float> destination,
         [ConstantExpected] byte control)
     {
-        VerifyShuffle4SpanInput(source, dest);
+        VerifyShuffle4SpanInput(source, destination);
 
-        HwIntrinsics.Shuffle4Reduce(ref source, ref dest, control);
+        HwIntrinsics.Shuffle4Reduce(ref source, ref destination, control);
 
         // Deal with the remainder:
         if (source.Length > 0)
         {
-            Shuffle4Remainder(source, dest, control);
+            Shuffle4Remainder(source, destination, control);
         }
     }
 
     /// <summary>
     /// Shuffle 8-bit integers within 128-bit lanes in <paramref name="source"/>
-    /// using the control and store the results in <paramref name="dest"/>.
+    /// using the control and store the results in <paramref name="destination"/>.
     /// </summary>
     /// <typeparam name="TShuffle">The type of shuffle struct.</typeparam>
     /// <param name="source">The source span of bytes.</param>
-    /// <param name="dest">The destination span of bytes.</param>
+    /// <param name="destination">The destination span of bytes.</param>
     /// <param name="shuffle">The type of shuffle to perform.</param>
     [MethodImpl(InliningOptions.ShortMethod)]
     public static void Shuffle4<TShuffle>(
         ReadOnlySpan<byte> source,
-        Span<byte> dest,
+        Span<byte> destination,
         TShuffle shuffle)
         where TShuffle : struct, IShuffle4
     {
-        VerifyShuffle4SpanInput(source, dest);
+        VerifyShuffle4SpanInput(source, destination);
 
-        shuffle.ShuffleReduce(ref source, ref dest);
+        shuffle.ShuffleReduce(ref source, ref destination);
 
         // Deal with the remainder:
         if (source.Length > 0)
         {
-            shuffle.RunFallbackShuffle(source, dest);
+            shuffle.Shuffle(source, destination);
         }
     }
 
     /// <summary>
     /// Shuffle 8-bit integer triplets within 128-bit lanes in <paramref name="source"/>
-    /// using the control and store the results in <paramref name="dest"/>.
+    /// using the control and store the results in <paramref name="destination"/>.
     /// </summary>
     /// <typeparam name="TShuffle">The type of shuffle struct.</typeparam>
     /// <param name="source">The source span of bytes.</param>
-    /// <param name="dest">The destination span of bytes.</param>
+    /// <param name="destination">The destination span of bytes.</param>
     /// <param name="shuffle">The type of shuffle to perform.</param>
     [MethodImpl(InliningOptions.ShortMethod)]
     public static void Shuffle3<TShuffle>(
         ReadOnlySpan<byte> source,
-        Span<byte> dest,
+        Span<byte> destination,
         TShuffle shuffle)
         where TShuffle : struct, IShuffle3
     {
-        // Source length should be smaller than dest length, and divisible by 3.
-        VerifyShuffle3SpanInput(source, dest);
+        // Source length should be smaller than destination length, and divisible by 3.
+        VerifyShuffle3SpanInput(source, destination);
 
-        shuffle.ShuffleReduce(ref source, ref dest);
+        shuffle.ShuffleReduce(ref source, ref destination);
 
         // Deal with the remainder:
         if (source.Length > 0)
         {
-            shuffle.RunFallbackShuffle(source, dest);
+            shuffle.Shuffle(source, destination);
         }
     }
 
     /// <summary>
     /// Pads then shuffles 8-bit integers within 128-bit lanes in <paramref name="source"/>
-    /// using the control and store the results in <paramref name="dest"/>.
+    /// using the control and store the results in <paramref name="destination"/>.
     /// </summary>
     /// <typeparam name="TShuffle">The type of shuffle struct.</typeparam>
     /// <param name="source">The source span of bytes.</param>
-    /// <param name="dest">The destination span of bytes.</param>
+    /// <param name="destination">The destination span of bytes.</param>
     /// <param name="shuffle">The type of shuffle to perform.</param>
     [MethodImpl(InliningOptions.ShortMethod)]
     public static void Pad3Shuffle4<TShuffle>(
         ReadOnlySpan<byte> source,
-        Span<byte> dest,
+        Span<byte> destination,
         TShuffle shuffle)
         where TShuffle : struct, IPad3Shuffle4
     {
-        VerifyPad3Shuffle4SpanInput(source, dest);
+        VerifyPad3Shuffle4SpanInput(source, destination);
 
-        shuffle.ShuffleReduce(ref source, ref dest);
+        shuffle.ShuffleReduce(ref source, ref destination);
 
         // Deal with the remainder:
         if (source.Length > 0)
         {
-            shuffle.RunFallbackShuffle(source, dest);
+            shuffle.Shuffle(source, destination);
         }
     }
 
     /// <summary>
     /// Shuffles then slices 8-bit integers within 128-bit lanes in <paramref name="source"/>
-    /// using the control and store the results in <paramref name="dest"/>.
+    /// using the control and store the results in <paramref name="destination"/>.
     /// </summary>
     /// <typeparam name="TShuffle">The type of shuffle struct.</typeparam>
     /// <param name="source">The source span of bytes.</param>
-    /// <param name="dest">The destination span of bytes.</param>
+    /// <param name="destination">The destination span of bytes.</param>
     /// <param name="shuffle">The type of shuffle to perform.</param>
     [MethodImpl(InliningOptions.ShortMethod)]
     public static void Shuffle4Slice3<TShuffle>(
         ReadOnlySpan<byte> source,
-        Span<byte> dest,
+        Span<byte> destination,
         TShuffle shuffle)
         where TShuffle : struct, IShuffle4Slice3
     {
-        VerifyShuffle4Slice3SpanInput(source, dest);
+        VerifyShuffle4Slice3SpanInput(source, destination);
 
-        shuffle.ShuffleReduce(ref source, ref dest);
+        shuffle.ShuffleReduce(ref source, ref destination);
 
         // Deal with the remainder:
         if (source.Length > 0)
         {
-            shuffle.RunFallbackShuffle(source, dest);
+            shuffle.Shuffle(source, destination);
         }
     }
 
     private static void Shuffle4Remainder(
         ReadOnlySpan<float> source,
-        Span<float> dest,
+        Span<float> destination,
         byte control)
     {
         ref float sBase = ref MemoryMarshal.GetReference(source);
-        ref float dBase = ref MemoryMarshal.GetReference(dest);
+        ref float dBase = ref MemoryMarshal.GetReference(destination);
         Shuffle.InverseMMShuffle(control, out uint p3, out uint p2, out uint p1, out uint p0);
 
         for (nuint i = 0; i < (uint)source.Length; i += 4)
@@ -158,69 +158,69 @@ internal static partial class SimdUtils
     }
 
     [Conditional("DEBUG")]
-    internal static void VerifyShuffle4SpanInput<T>(ReadOnlySpan<T> source, Span<T> dest)
+    internal static void VerifyShuffle4SpanInput<T>(ReadOnlySpan<T> source, Span<T> destination)
         where T : struct
     {
         DebugGuard.IsTrue(
-            source.Length == dest.Length,
+            source.Length == destination.Length,
             nameof(source),
             "Input spans must be of same length!");
 
         DebugGuard.IsTrue(
             source.Length % 4 == 0,
             nameof(source),
-            "Input spans must be divisable by 4!");
+            "Input spans must be divisible by 4!");
     }
 
     [Conditional("DEBUG")]
-    private static void VerifyShuffle3SpanInput<T>(ReadOnlySpan<T> source, Span<T> dest)
+    private static void VerifyShuffle3SpanInput<T>(ReadOnlySpan<T> source, Span<T> destination)
         where T : struct
     {
         DebugGuard.IsTrue(
-            source.Length <= dest.Length,
+            source.Length <= destination.Length,
             nameof(source),
-            "Source should fit into dest!");
+            "Source should fit into destination!");
 
         DebugGuard.IsTrue(
             source.Length % 3 == 0,
             nameof(source),
-            "Input spans must be divisable by 3!");
+            "Input spans must be divisible by 3!");
     }
 
     [Conditional("DEBUG")]
-    private static void VerifyPad3Shuffle4SpanInput(ReadOnlySpan<byte> source, Span<byte> dest)
+    private static void VerifyPad3Shuffle4SpanInput(ReadOnlySpan<byte> source, Span<byte> destination)
     {
         DebugGuard.IsTrue(
             source.Length % 3 == 0,
             nameof(source),
-            "Input span must be divisable by 3!");
+            "Input span must be divisible by 3!");
 
         DebugGuard.IsTrue(
-            dest.Length % 4 == 0,
-            nameof(dest),
-            "Output span must be divisable by 4!");
+            destination.Length % 4 == 0,
+            nameof(destination),
+            "Output span must be divisible by 4!");
 
         DebugGuard.IsTrue(
-            source.Length == dest.Length * 3 / 4,
+            source.Length == destination.Length * 3 / 4,
             nameof(source),
             "Input span must be 3/4 the length of the output span!");
     }
 
     [Conditional("DEBUG")]
-    private static void VerifyShuffle4Slice3SpanInput(ReadOnlySpan<byte> source, Span<byte> dest)
+    private static void VerifyShuffle4Slice3SpanInput(ReadOnlySpan<byte> source, Span<byte> destination)
     {
         DebugGuard.IsTrue(
             source.Length % 4 == 0,
             nameof(source),
-            "Input span must be divisable by 4!");
+            "Input span must be divisible by 4!");
 
         DebugGuard.IsTrue(
-            dest.Length % 3 == 0,
-            nameof(dest),
-            "Output span must be divisable by 3!");
+            destination.Length % 3 == 0,
+            nameof(destination),
+            "Output span must be divisible by 3!");
 
         DebugGuard.IsTrue(
-            dest.Length >= source.Length * 3 / 4,
+            destination.Length >= source.Length * 3 / 4,
             nameof(source),
             "Output span must be at least 3/4 the length of the input span!");
     }
@@ -509,6 +509,27 @@ internal static partial class SimdUtils
             }
         }
 
+        [MethodImpl(InliningOptions.ShortMethod)]
+        public static void MMShuffleSpan(ref Span<int> span, byte control)
+        {
+            InverseMMShuffle(
+                 control,
+                 out uint p3,
+                 out uint p2,
+                 out uint p1,
+                 out uint p0);
+
+            ref int spanBase = ref MemoryMarshal.GetReference(span);
+
+            for (nuint i = 0; i < (uint)span.Length; i += 4)
+            {
+                Unsafe.Add(ref spanBase, i + 0) = (int)(p0 + i);
+                Unsafe.Add(ref spanBase, i + 1) = (int)(p1 + i);
+                Unsafe.Add(ref spanBase, i + 2) = (int)(p2 + i);
+                Unsafe.Add(ref spanBase, i + 3) = (int)(p3 + i);
+            }
+        }
+
         [MethodImpl(InliningOptions.ShortMethod)]
         public static void InverseMMShuffle(
             byte control,
diff --git a/src/ImageSharp/Common/Helpers/Vector128Utilities.cs b/src/ImageSharp/Common/Helpers/Vector128Utilities.cs
new file mode 100644
index 000000000..981f9a47f
--- /dev/null
+++ b/src/ImageSharp/Common/Helpers/Vector128Utilities.cs
@@ -0,0 +1,176 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
+using System.Runtime.Intrinsics;
+using System.Runtime.Intrinsics.Arm;
+using System.Runtime.Intrinsics.X86;
+
+namespace SixLabors.ImageSharp.Common.Helpers;
+
+/// <summary>
+/// Defines utility methods for <see cref="Vector128{T}"/> that have either:
+/// <list type="number">
+/// <item>Not yet been normalized in the runtime.</item>
+/// <item>Produce codegen that is poorly optimized by the runtime.</item>
+/// </list>
+/// Should only be used if the intrinsics are available.
+/// </summary>
+internal static class Vector128Utilities
+{
+    /// <summary>
+    /// Gets a value indicating whether shuffle operations are supported.
+    /// </summary>
+    public static bool SupportsShuffleFloat
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        get => Sse.IsSupported;
+    }
+
+    /// <summary>
+    /// Gets a value indicating whether shuffle operations are supported.
+    /// </summary>
+    public static bool SupportsShuffleByte
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        get => Ssse3.IsSupported || AdvSimd.Arm64.IsSupported;
+    }
+
+    /// <summary>
+    /// Gets a value indicating whether right align operations are supported.
+    /// </summary>
+    public static bool SupportsRightAlign
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        get => Ssse3.IsSupported || AdvSimd.IsSupported;
+    }
+
+    /// <summary>
+    /// Gets a value indicating whether right or left byte shift operations are supported.
+    /// </summary>
+    public static bool SupportsShiftByte
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        get => Sse2.IsSupported || AdvSimd.IsSupported;
+    }
+
+    /// <summary>
+    /// Creates a new vector by selecting values from an input vector using the control.
+    /// </summary>
+    /// <param name="vector">The input vector from which values are selected.</param>
+    /// <param name="control">The shuffle control byte.</param>
+    /// <returns>The <see cref="Vector128{Single}"/>.</returns>
+    public static Vector128<float> Shuffle(Vector128<float> vector, [ConstantExpected] byte control)
+    {
+        if (Sse.IsSupported)
+        {
+            return Sse.Shuffle(vector, vector, control);
+        }
+
+        ThrowUnreachableException();
+        return default;
+    }
+
+    /// <summary>
+    /// Creates a new vector by selecting values from an input vector using a set of indices.
+    /// </summary>
+    /// <param name="vector">
+    /// The input vector from which values are selected.</param>
+    /// <param name="indices">
+    /// The per-element indices used to select a value from <paramref name="vector" />.
+    /// </param>
+    /// <returns>
+    /// A new vector containing the values from <paramref name="vector" /> selected by the given <paramref name="indices" />.
+    /// </returns>
+    public static Vector128<byte> Shuffle(Vector128<byte> vector, Vector128<byte> indices)
+    {
+        if (Ssse3.IsSupported)
+        {
+            return Ssse3.Shuffle(vector, indices);
+        }
+
+        if (AdvSimd.Arm64.IsSupported)
+        {
+            return AdvSimd.Arm64.VectorTableLookup(vector, indices);
+        }
+
+        ThrowUnreachableException();
+        return default;
+    }
+
+    /// <summary>
+    /// Shifts a 128-bit value right by a specified number of bytes while shifting in zeros.
+    /// </summary>
+    /// <param name="value">The value to shift.</param>
+    /// <param name="numBytes">The number of bytes to shift by.</param>
+    /// <returns>The <see cref="Vector128{Byte}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector128<byte> ShiftRightBytesInVector(Vector128<byte> value, [ConstantExpected(Max = (byte)15)] byte numBytes)
+    {
+        if (Sse2.IsSupported)
+        {
+            return Sse2.ShiftRightLogical128BitLane(value, numBytes);
+        }
+
+        if (AdvSimd.IsSupported)
+        {
+            return AdvSimd.ExtractVector128(value, Vector128<byte>.Zero, numBytes);
+        }
+
+        ThrowUnreachableException();
+        return default;
+    }
+
+    /// <summary>
+    /// Shifts a 128-bit value left by a specified number of bytes while shifting in zeros.
+    /// </summary>
+    /// <param name="value">The value to shift.</param>
+    /// <param name="numBytes">The number of bytes to shift by.</param>
+    /// <returns>The <see cref="Vector128{Byte}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector128<byte> ShiftLeftBytesInVector(Vector128<byte> value, [ConstantExpected(Max = (byte)15)] byte numBytes)
+    {
+        if (Sse2.IsSupported)
+        {
+            return Sse2.ShiftLeftLogical128BitLane(value, numBytes);
+        }
+
+        if (AdvSimd.IsSupported)
+        {
+#pragma warning disable CA1857 // A constant is expected for the parameter
+            return AdvSimd.ExtractVector128(Vector128<byte>.Zero, value, (byte)(Vector128<byte>.Count - numBytes));
+#pragma warning restore CA1857 // A constant is expected for the parameter
+        }
+
+        ThrowUnreachableException();
+        return default;
+    }
+
+    /// <summary>
+    /// Right aligns elements of two source 128-bit values depending on bits in a mask.
+    /// </summary>
+    /// <param name="left">The left hand source vector.</param>
+    /// <param name="right">The right hand source vector.</param>
+    /// <param name="mask">An 8-bit mask used for the operation.</param>
+    /// <returns>The <see cref="Vector128{Byte}"/>.</returns>
+    public static Vector128<byte> AlignRight(Vector128<byte> left, Vector128<byte> right, [ConstantExpected(Max = (byte)15)] byte mask)
+    {
+        if (Ssse3.IsSupported)
+        {
+            return Ssse3.AlignRight(left, right, mask);
+        }
+
+        if (AdvSimd.IsSupported)
+        {
+            return AdvSimd.ExtractVector128(right, left, mask);
+        }
+
+        ThrowUnreachableException();
+        return default;
+    }
+
+    [DoesNotReturn]
+    private static void ThrowUnreachableException() => throw new UnreachableException();
+}
diff --git a/src/ImageSharp/Common/Helpers/Vector256Utilities.cs b/src/ImageSharp/Common/Helpers/Vector256Utilities.cs
new file mode 100644
index 000000000..14fa24b31
--- /dev/null
+++ b/src/ImageSharp/Common/Helpers/Vector256Utilities.cs
@@ -0,0 +1,78 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
+using System.Runtime.Intrinsics;
+using System.Runtime.Intrinsics.X86;
+
+namespace SixLabors.ImageSharp.Common.Helpers;
+
+/// <summary>
+/// Defines utility methods for <see cref="Vector256{T}"/> that have either:
+/// <list type="number">
+/// <item>Not yet been normalized in the runtime.</item>
+/// <item>Produce codegen that is poorly optimized by the runtime.</item>
+/// </list>
+/// Should only be used if the intrinsics are available.
+/// </summary>
+internal static class Vector256Utilities
+{
+    /// <summary>
+    /// Gets a value indicating whether shuffle byte operations are supported.
+    /// </summary>
+    public static bool SupportsShuffleFloat
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        get => Avx.IsSupported;
+    }
+
+    /// <summary>
+    /// Gets a value indicating whether shuffle byte operations are supported.
+    /// </summary>
+    public static bool SupportsShuffleByte
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        get => Avx2.IsSupported;
+    }
+
+    /// <summary>
+    /// Creates a new vector by selecting values from an input vector using a set of indices.
+    /// </summary>
+    /// <param name="vector">The input vector from which values are selected.</param>
+    /// <param name="control">The shuffle control byte.</param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    public static Vector256<float> Shuffle(Vector256<float> vector, [ConstantExpected] byte control)
+    {
+        if (Avx.IsSupported)
+        {
+            return Avx.Shuffle(vector, vector, control);
+        }
+
+        ThrowUnreachableException();
+        return default;
+    }
+
+    /// <summary>
+    /// Creates a new vector by selecting values from an input vector using a set of indices.</summary>
+    /// <param name="vector">
+    /// The input vector from which values are selected.</param>
+    /// <param name="indices">
+    /// The per-element indices used to select a value from <paramref name="vector" />.
+    /// </param>
+    /// <returns>The <see cref="Vector256{Single}"/>.</returns>
+    public static Vector256<byte> Shuffle(Vector256<byte> vector, Vector256<byte> indices)
+    {
+        if (Avx2.IsSupported)
+        {
+            return Avx2.Shuffle(vector, indices);
+        }
+
+        ThrowUnreachableException();
+        return default;
+    }
+
+    [DoesNotReturn]
+    private static void ThrowUnreachableException() => throw new UnreachableException();
+}
diff --git a/src/ImageSharp/Common/Helpers/Vector512Utilities.cs b/src/ImageSharp/Common/Helpers/Vector512Utilities.cs
new file mode 100644
index 000000000..5488b4064
--- /dev/null
+++ b/src/ImageSharp/Common/Helpers/Vector512Utilities.cs
@@ -0,0 +1,80 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
+using System.Runtime.Intrinsics;
+using System.Runtime.Intrinsics.X86;
+
+namespace SixLabors.ImageSharp.Common.Helpers;
+
+/// <summary>
+/// Defines utility methods for <see cref="Vector512{T}"/> that have either:
+/// <list type="number">
+/// <item>Not yet been normalized in the runtime.</item>
+/// <item>Produce codegen that is poorly optimized by the runtime.</item>
+/// </list>
+/// Should only be used if the intrinsics are available.
+/// </summary>
+internal static class Vector512Utilities
+{
+    /// <summary>
+    /// Gets a value indicating whether shuffle float operations are supported.
+    /// </summary>
+    public static bool SupportsShuffleFloat
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        get => Avx512F.IsSupported;
+    }
+
+    /// <summary>
+    /// Gets a value indicating whether shuffle byte operations are supported.
+    /// </summary>
+    public static bool SupportsShuffleByte
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        get => Avx512BW.IsSupported;
+    }
+
+    /// <summary>
+    /// Creates a new vector by selecting values from an input vector using the control.
+    /// </summary>
+    /// <param name="vector">The input vector from which values are selected.</param>
+    /// <param name="control">The shuffle control byte.</param>
+    /// <returns>The <see cref="Vector512{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> Shuffle(Vector512<float> vector, [ConstantExpected] byte control)
+    {
+        if (Avx512F.IsSupported)
+        {
+            return Avx512F.Shuffle(vector, vector, control);
+        }
+
+        ThrowUnreachableException();
+        return default;
+    }
+
+    /// <summary>
+    /// Creates a new vector by selecting values from an input vector using a set of indices.
+    /// </summary>
+    /// <param name="vector">The input vector from which values are selected.</param>
+    /// <param name="indices">
+    /// The per-element indices used to select a value from <paramref name="vector" />.
+    /// </param>
+    /// <returns>The <see cref="Vector512{Byte}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<byte> Shuffle(Vector512<byte> vector, Vector512<byte> indices)
+    {
+        if (Avx512BW.IsSupported)
+        {
+            return Avx512BW.Shuffle(vector, indices);
+        }
+
+        ThrowUnreachableException();
+        return default;
+    }
+
+    [DoesNotReturn]
+    private static void ThrowUnreachableException() => throw new UnreachableException();
+}
diff --git a/src/ImageSharp/Formats/AnimationUtilities.cs b/src/ImageSharp/Formats/AnimationUtilities.cs
index 288f3d132..4605d4daa 100644
--- a/src/ImageSharp/Formats/AnimationUtilities.cs
+++ b/src/ImageSharp/Formats/AnimationUtilities.cs
@@ -50,7 +50,7 @@ internal static class AnimationUtilities
         Span<Rgba32> next = buffers.GetSpan().Slice(currentFrame.Width * 2, currentFrame.Width);
         Span<Rgba32> result = buffers.GetSpan()[(currentFrame.Width * 3)..];
 
-        Rgba32 bg = replacement;
+        Rgba32 bg = replacement.ToPixel<Rgba32>();
 
         int top = int.MinValue;
         int bottom = int.MaxValue;
@@ -232,7 +232,7 @@ internal static class AnimationUtilities
                 ref Rgba32 r = ref Unsafe.Add(ref MemoryMarshal.GetReference(result), x);
 
                 bool peq = c.Rgba == (previousFrame != null ? p.Rgba : bg.Rgba);
-                Rgba32 val = (blend & peq) ? replacement : c;
+                Rgba32 val = (blend & peq) ? bg : c;
 
                 peq &= nextFrame == null || (n.Rgba >> 24 >= c.Rgba >> 24);
                 r = val;
diff --git a/src/ImageSharp/Formats/Bmp/BmpDecoderCore.cs b/src/ImageSharp/Formats/Bmp/BmpDecoderCore.cs
index 863fed359..bed489752 100644
--- a/src/ImageSharp/Formats/Bmp/BmpDecoderCore.cs
+++ b/src/ImageSharp/Formats/Bmp/BmpDecoderCore.cs
@@ -294,72 +294,60 @@ internal sealed class BmpDecoderCore : IImageDecoderInternals
     private void ReadRle<TPixel>(BufferedReadStream stream, BmpCompression compression, Buffer2D<TPixel> pixels, byte[] colors, int width, int height, bool inverted)
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        TPixel color = default;
-        using (IMemoryOwner<byte> buffer = this.memoryAllocator.Allocate<byte>(width * height, AllocationOptions.Clean))
-        using (IMemoryOwner<bool> undefinedPixels = this.memoryAllocator.Allocate<bool>(width * height, AllocationOptions.Clean))
-        using (IMemoryOwner<bool> rowsWithUndefinedPixels = this.memoryAllocator.Allocate<bool>(height, AllocationOptions.Clean))
+        using IMemoryOwner<byte> buffer = this.memoryAllocator.Allocate<byte>(width * height, AllocationOptions.Clean);
+        using IMemoryOwner<bool> undefinedPixels = this.memoryAllocator.Allocate<bool>(width * height, AllocationOptions.Clean);
+        using IMemoryOwner<bool> rowsWithUndefinedPixels = this.memoryAllocator.Allocate<bool>(height, AllocationOptions.Clean);
+        Span<bool> rowsWithUndefinedPixelsSpan = rowsWithUndefinedPixels.Memory.Span;
+        Span<bool> undefinedPixelsSpan = undefinedPixels.Memory.Span;
+        Span<byte> bufferSpan = buffer.Memory.Span;
+        if (compression is BmpCompression.RLE8)
         {
-            Span<bool> rowsWithUndefinedPixelsSpan = rowsWithUndefinedPixels.Memory.Span;
-            Span<bool> undefinedPixelsSpan = undefinedPixels.Memory.Span;
-            Span<byte> bufferSpan = buffer.Memory.Span;
-            if (compression is BmpCompression.RLE8)
-            {
-                this.UncompressRle8(stream, width, bufferSpan, undefinedPixelsSpan, rowsWithUndefinedPixelsSpan);
-            }
-            else
-            {
-                this.UncompressRle4(stream, width, bufferSpan, undefinedPixelsSpan, rowsWithUndefinedPixelsSpan);
-            }
+            this.UncompressRle8(stream, width, bufferSpan, undefinedPixelsSpan, rowsWithUndefinedPixelsSpan);
+        }
+        else
+        {
+            this.UncompressRle4(stream, width, bufferSpan, undefinedPixelsSpan, rowsWithUndefinedPixelsSpan);
+        }
 
-            for (int y = 0; y < height; y++)
-            {
-                int newY = Invert(y, height, inverted);
-                int rowStartIdx = y * width;
-                Span<byte> bufferRow = bufferSpan.Slice(rowStartIdx, width);
-                Span<TPixel> pixelRow = pixels.DangerousGetRowSpan(newY);
+        for (int y = 0; y < height; y++)
+        {
+            int newY = Invert(y, height, inverted);
+            int rowStartIdx = y * width;
+            Span<byte> bufferRow = bufferSpan.Slice(rowStartIdx, width);
+            Span<TPixel> pixelRow = pixels.DangerousGetRowSpan(newY);
 
-                bool rowHasUndefinedPixels = rowsWithUndefinedPixelsSpan[y];
-                if (rowHasUndefinedPixels)
+            bool rowHasUndefinedPixels = rowsWithUndefinedPixelsSpan[y];
+            if (rowHasUndefinedPixels)
+            {
+                // Slow path with undefined pixels.
+                for (int x = 0; x < width; x++)
                 {
-                    // Slow path with undefined pixels.
-                    for (int x = 0; x < width; x++)
+                    byte colorIdx = bufferRow[x];
+                    if (undefinedPixelsSpan[rowStartIdx + x])
                     {
-                        byte colorIdx = bufferRow[x];
-                        if (undefinedPixelsSpan[rowStartIdx + x])
-                        {
-                            switch (this.rleSkippedPixelHandling)
-                            {
-                                case RleSkippedPixelHandling.FirstColorOfPalette:
-                                    color.FromBgr24(Unsafe.As<byte, Bgr24>(ref colors[colorIdx * 4]));
-                                    break;
-                                case RleSkippedPixelHandling.Transparent:
-                                    color.FromScaledVector4(Vector4.Zero);
-                                    break;
-
-                                // Default handling for skipped pixels is black (which is what System.Drawing is also doing).
-                                default:
-                                    color.FromScaledVector4(new Vector4(0.0f, 0.0f, 0.0f, 1.0f));
-                                    break;
-                            }
-                        }
-                        else
+                        pixelRow[x] = this.rleSkippedPixelHandling switch
                         {
-                            color.FromBgr24(Unsafe.As<byte, Bgr24>(ref colors[colorIdx * 4]));
-                        }
+                            RleSkippedPixelHandling.FirstColorOfPalette => TPixel.FromBgr24(Unsafe.As<byte, Bgr24>(ref colors[colorIdx * 4])),
+                            RleSkippedPixelHandling.Transparent => TPixel.FromScaledVector4(Vector4.Zero),
 
-                        pixelRow[x] = color;
+                            // Default handling for skipped pixels is black (which is what System.Drawing is also doing).
+                            _ => TPixel.FromScaledVector4(new Vector4(0.0f, 0.0f, 0.0f, 1.0f)),
+                        };
                     }
-                }
-                else
-                {
-                    // Fast path without any undefined pixels.
-                    for (int x = 0; x < width; x++)
+                    else
                     {
-                        color.FromBgr24(Unsafe.As<byte, Bgr24>(ref colors[bufferRow[x] * 4]));
-                        pixelRow[x] = color;
+                        pixelRow[x] = TPixel.FromBgr24(Unsafe.As<byte, Bgr24>(ref colors[colorIdx * 4]));
                     }
                 }
             }
+            else
+            {
+                // Fast path without any undefined pixels.
+                for (int x = 0; x < width; x++)
+                {
+                    pixelRow[x] = TPixel.FromBgr24(Unsafe.As<byte, Bgr24>(ref colors[bufferRow[x] * 4]));
+                }
+            }
         }
     }
 
@@ -375,66 +363,54 @@ internal sealed class BmpDecoderCore : IImageDecoderInternals
     private void ReadRle24<TPixel>(BufferedReadStream stream, Buffer2D<TPixel> pixels, int width, int height, bool inverted)
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        TPixel color = default;
-        using (IMemoryOwner<byte> buffer = this.memoryAllocator.Allocate<byte>(width * height * 3, AllocationOptions.Clean))
-        using (IMemoryOwner<bool> undefinedPixels = this.memoryAllocator.Allocate<bool>(width * height, AllocationOptions.Clean))
-        using (IMemoryOwner<bool> rowsWithUndefinedPixels = this.memoryAllocator.Allocate<bool>(height, AllocationOptions.Clean))
-        {
-            Span<bool> rowsWithUndefinedPixelsSpan = rowsWithUndefinedPixels.Memory.Span;
-            Span<bool> undefinedPixelsSpan = undefinedPixels.Memory.Span;
-            Span<byte> bufferSpan = buffer.GetSpan();
+        using IMemoryOwner<byte> buffer = this.memoryAllocator.Allocate<byte>(width * height * 3, AllocationOptions.Clean);
+        using IMemoryOwner<bool> undefinedPixels = this.memoryAllocator.Allocate<bool>(width * height, AllocationOptions.Clean);
+        using IMemoryOwner<bool> rowsWithUndefinedPixels = this.memoryAllocator.Allocate<bool>(height, AllocationOptions.Clean);
+        Span<bool> rowsWithUndefinedPixelsSpan = rowsWithUndefinedPixels.Memory.Span;
+        Span<bool> undefinedPixelsSpan = undefinedPixels.Memory.Span;
+        Span<byte> bufferSpan = buffer.GetSpan();
 
-            this.UncompressRle24(stream, width, bufferSpan, undefinedPixelsSpan, rowsWithUndefinedPixelsSpan);
-            for (int y = 0; y < height; y++)
+        this.UncompressRle24(stream, width, bufferSpan, undefinedPixelsSpan, rowsWithUndefinedPixelsSpan);
+        for (int y = 0; y < height; y++)
+        {
+            int newY = Invert(y, height, inverted);
+            Span<TPixel> pixelRow = pixels.DangerousGetRowSpan(newY);
+            bool rowHasUndefinedPixels = rowsWithUndefinedPixelsSpan[y];
+            if (rowHasUndefinedPixels)
             {
-                int newY = Invert(y, height, inverted);
-                Span<TPixel> pixelRow = pixels.DangerousGetRowSpan(newY);
-                bool rowHasUndefinedPixels = rowsWithUndefinedPixelsSpan[y];
-                if (rowHasUndefinedPixels)
+                // Slow path with undefined pixels.
+                int yMulWidth = y * width;
+                int rowStartIdx = yMulWidth * 3;
+                for (int x = 0; x < width; x++)
                 {
-                    // Slow path with undefined pixels.
-                    int yMulWidth = y * width;
-                    int rowStartIdx = yMulWidth * 3;
-                    for (int x = 0; x < width; x++)
+                    int idx = rowStartIdx + (x * 3);
+                    if (undefinedPixelsSpan[yMulWidth + x])
                     {
-                        int idx = rowStartIdx + (x * 3);
-                        if (undefinedPixelsSpan[yMulWidth + x])
-                        {
-                            switch (this.rleSkippedPixelHandling)
-                            {
-                                case RleSkippedPixelHandling.FirstColorOfPalette:
-                                    color.FromBgr24(Unsafe.As<byte, Bgr24>(ref bufferSpan[idx]));
-                                    break;
-                                case RleSkippedPixelHandling.Transparent:
-                                    color.FromScaledVector4(Vector4.Zero);
-                                    break;
-
-                                // Default handling for skipped pixels is black (which is what System.Drawing is also doing).
-                                default:
-                                    color.FromScaledVector4(new Vector4(0.0f, 0.0f, 0.0f, 1.0f));
-                                    break;
-                            }
-                        }
-                        else
+                        pixelRow[x] = this.rleSkippedPixelHandling switch
                         {
-                            color.FromBgr24(Unsafe.As<byte, Bgr24>(ref bufferSpan[idx]));
-                        }
+                            RleSkippedPixelHandling.FirstColorOfPalette => TPixel.FromBgr24(Unsafe.As<byte, Bgr24>(ref bufferSpan[idx])),
+                            RleSkippedPixelHandling.Transparent => TPixel.FromScaledVector4(Vector4.Zero),
 
-                        pixelRow[x] = color;
+                            // Default handling for skipped pixels is black (which is what System.Drawing is also doing).
+                            _ => TPixel.FromScaledVector4(new Vector4(0.0f, 0.0f, 0.0f, 1.0f)),
+                        };
                     }
-                }
-                else
-                {
-                    // Fast path without any undefined pixels.
-                    int rowStartIdx = y * width * 3;
-                    for (int x = 0; x < width; x++)
+                    else
                     {
-                        int idx = rowStartIdx + (x * 3);
-                        color.FromBgr24(Unsafe.As<byte, Bgr24>(ref bufferSpan[idx]));
-                        pixelRow[x] = color;
+                        pixelRow[x] = TPixel.FromBgr24(Unsafe.As<byte, Bgr24>(ref bufferSpan[idx]));
                     }
                 }
             }
+            else
+            {
+                // Fast path without any undefined pixels.
+                int rowStartIdx = y * width * 3;
+                for (int x = 0; x < width; x++)
+                {
+                    int idx = rowStartIdx + (x * 3);
+                    pixelRow[x] = TPixel.FromBgr24(Unsafe.As<byte, Bgr24>(ref bufferSpan[idx]));
+                }
+            }
         }
     }
 
@@ -492,7 +468,7 @@ internal sealed class BmpDecoderCore : IImageDecoderInternals
                         int max = cmd[1];
                         int bytesToRead = (int)(((uint)max + 1) / 2);
 
-                        Span<byte> run = bytesToRead <= 128 ? scratchBuffer.Slice(0, bytesToRead) : new byte[bytesToRead];
+                        Span<byte> run = bytesToRead <= 128 ? scratchBuffer[..bytesToRead] : new byte[bytesToRead];
 
                         stream.Read(run);
 
@@ -598,7 +574,7 @@ internal sealed class BmpDecoderCore : IImageDecoderInternals
                         // Take this number of bytes from the stream as uncompressed data.
                         int length = cmd[1];
 
-                        Span<byte> run = length <= 128 ? scratchBuffer.Slice(0, length) : new byte[length];
+                        Span<byte> run = length <= 128 ? scratchBuffer[..length] : new byte[length];
 
                         stream.Read(run);
 
@@ -680,7 +656,7 @@ internal sealed class BmpDecoderCore : IImageDecoderInternals
                         int length = cmd[1];
                         int length3 = length * 3;
 
-                        Span<byte> run = length3 <= 128 ? scratchBuffer.Slice(0, length3) : new byte[length3];
+                        Span<byte> run = length3 <= 128 ? scratchBuffer[..length3] : new byte[length3];
 
                         stream.Read(run);
 
@@ -835,7 +811,6 @@ internal sealed class BmpDecoderCore : IImageDecoderInternals
         }
 
         using IMemoryOwner<byte> row = this.memoryAllocator.Allocate<byte>(arrayWidth + padding, AllocationOptions.Clean);
-        TPixel color = default;
         Span<byte> rowSpan = row.GetSpan();
 
         for (int y = 0; y < height; y++)
@@ -856,8 +831,7 @@ internal sealed class BmpDecoderCore : IImageDecoderInternals
                 {
                     int colorIndex = ((rowSpan[offset] >> (8 - bitsPerPixel - (shift * bitsPerPixel))) & mask) * bytesPerColorMapEntry;
 
-                    color.FromBgr24(Unsafe.As<byte, Bgr24>(ref colors[colorIndex]));
-                    pixelRow[newX] = color;
+                    pixelRow[newX] = TPixel.FromBgr24(Unsafe.As<byte, Bgr24>(ref colors[colorIndex]));
                 }
 
                 offset++;
@@ -882,8 +856,6 @@ internal sealed class BmpDecoderCore : IImageDecoderInternals
     {
         int padding = CalculatePadding(width, 2);
         int stride = (width * 2) + padding;
-        TPixel color = default;
-
         int rightShiftRedMask = CalculateRightShift((uint)redMask);
         int rightShiftGreenMask = CalculateRightShift((uint)greenMask);
         int rightShiftBlueMask = CalculateRightShift((uint)blueMask);
@@ -917,8 +889,7 @@ internal sealed class BmpDecoderCore : IImageDecoderInternals
                 int b = (blueMaskBits == 5) ? GetBytesFrom5BitValue((temp & blueMask) >> rightShiftBlueMask) : GetBytesFrom6BitValue((temp & blueMask) >> rightShiftBlueMask);
                 Rgb24 rgb = new((byte)r, (byte)g, (byte)b);
 
-                color.FromRgb24(rgb);
-                pixelRow[x] = color;
+                pixelRow[x] = TPixel.FromRgb24(rgb);
                 offset += 2;
             }
         }
@@ -1107,8 +1078,7 @@ internal sealed class BmpDecoderCore : IImageDecoderInternals
             {
                 Bgra32 bgra = bgraRowSpan[x];
                 bgra.A = byte.MaxValue;
-                ref TPixel pixel = ref pixelSpan[x];
-                pixel.FromBgra32(bgra);
+                pixelSpan[x] = TPixel.FromBgra32(bgra);
             }
         }
     }
@@ -1129,7 +1099,6 @@ internal sealed class BmpDecoderCore : IImageDecoderInternals
     private void ReadRgb32BitFields<TPixel>(BufferedReadStream stream, Buffer2D<TPixel> pixels, int width, int height, bool inverted, int redMask, int greenMask, int blueMask, int alphaMask)
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        TPixel color = default;
         int padding = CalculatePadding(width, 4);
         int stride = (width * 4) + padding;
 
@@ -1179,18 +1148,17 @@ internal sealed class BmpDecoderCore : IImageDecoderInternals
                         g * invMaxValueGreen,
                         b * invMaxValueBlue,
                         alpha);
-                    color.FromScaledVector4(vector4);
+                    pixelRow[x] = TPixel.FromScaledVector4(vector4);
                 }
                 else
                 {
                     byte r = (byte)((temp & redMask) >> rightShiftRedMask);
                     byte g = (byte)((temp & greenMask) >> rightShiftGreenMask);
                     byte b = (byte)((temp & blueMask) >> rightShiftBlueMask);
-                    byte a = alphaMask != 0 ? (byte)((temp & alphaMask) >> rightShiftAlphaMask) : (byte)255;
-                    color.FromRgba32(new Rgba32(r, g, b, a));
+                    byte a = alphaMask != 0 ? (byte)((temp & alphaMask) >> rightShiftAlphaMask) : byte.MaxValue;
+                    pixelRow[x] = TPixel.FromRgba32(new(r, g, b, a));
                 }
 
-                pixelRow[x] = color;
                 offset += 4;
             }
         }
@@ -1468,7 +1436,7 @@ internal sealed class BmpDecoderCore : IImageDecoderInternals
             colorMapSizeBytes = this.infoHeader.ClrUsed * bytesPerColorMapEntry;
         }
 
-        palette = Array.Empty<byte>();
+        palette = [];
 
         if (colorMapSizeBytes > 0)
         {
diff --git a/src/ImageSharp/Formats/Gif/GifDecoderCore.cs b/src/ImageSharp/Formats/Gif/GifDecoderCore.cs
index aecbbbbc7..d64792eba 100644
--- a/src/ImageSharp/Formats/Gif/GifDecoderCore.cs
+++ b/src/ImageSharp/Formats/Gif/GifDecoderCore.cs
@@ -185,7 +185,7 @@ internal sealed class GifDecoderCore : IImageDecoderInternals
     {
         uint frameCount = 0;
         ImageFrameMetadata? previousFrame = null;
-        List<ImageFrameMetadata> framesMetadata = new();
+        List<ImageFrameMetadata> framesMetadata = [];
         try
         {
             this.ReadLogicalScreenDescriptorAndGlobalColorTable(stream);
@@ -595,9 +595,7 @@ internal sealed class GifDecoderCore : IImageDecoderInternals
                 for (int x = descriptorLeft; x < descriptorRight && x < imageWidth; x++)
                 {
                     int index = Numerics.Clamp(Unsafe.Add(ref indicesRowRef, (uint)(x - descriptorLeft)), 0, colorTableMaxIdx);
-                    ref TPixel pixel = ref Unsafe.Add(ref rowRef, (uint)x);
-                    Rgb24 rgb = colorTable[index];
-                    pixel.FromRgb24(rgb);
+                    Unsafe.Add(ref rowRef, (uint)x) = TPixel.FromRgb24(colorTable[index]);
                 }
             }
             else
@@ -613,9 +611,7 @@ internal sealed class GifDecoderCore : IImageDecoderInternals
                     }
 
                     int index = Numerics.Clamp(rawIndex, 0, colorTableMaxIdx);
-                    ref TPixel pixel = ref Unsafe.Add(ref rowRef, (uint)x);
-                    Rgb24 rgb = colorTable[index];
-                    pixel.FromRgb24(rgb);
+                    Unsafe.Add(ref rowRef, (uint)x) = TPixel.FromRgb24(colorTable[index]);
                 }
             }
         }
@@ -711,10 +707,7 @@ internal sealed class GifDecoderCore : IImageDecoderInternals
 
             Color[] colorTable = new Color[this.imageDescriptor.LocalColorTableSize];
             ReadOnlySpan<Rgb24> rgbTable = MemoryMarshal.Cast<byte, Rgb24>(this.currentLocalColorTable!.GetSpan()[..this.currentLocalColorTableSize]);
-            for (int i = 0; i < colorTable.Length; i++)
-            {
-                colorTable[i] = new Color(rgbTable[i]);
-            }
+            Color.FromPixel(rgbTable, colorTable);
 
             gifMeta.LocalColorTable = colorTable;
         }
@@ -789,10 +782,7 @@ internal sealed class GifDecoderCore : IImageDecoderInternals
 
                 Color[] colorTable = new Color[this.logicalScreenDescriptor.GlobalColorTableSize];
                 ReadOnlySpan<Rgb24> rgbTable = MemoryMarshal.Cast<byte, Rgb24>(globalColorTableSpan);
-                for (int i = 0; i < colorTable.Length; i++)
-                {
-                    colorTable[i] = new Color(rgbTable[i]);
-                }
+                Color.FromPixel(rgbTable, colorTable);
 
                 this.gifMetadata.GlobalColorTable = colorTable;
             }
diff --git a/src/ImageSharp/Formats/Gif/GifEncoderCore.cs b/src/ImageSharp/Formats/Gif/GifEncoderCore.cs
index 1215768e4..95429e606 100644
--- a/src/ImageSharp/Formats/Gif/GifEncoderCore.cs
+++ b/src/ImageSharp/Formats/Gif/GifEncoderCore.cs
@@ -169,7 +169,7 @@ internal sealed class GifEncoderCore : IImageEncoderInternals
         this.EncodeFirstFrame(stream, frameMetadata, quantized);
 
         // Capture the global palette for reuse on subsequent frames and cleanup the quantized frame.
-        TPixel[] globalPalette = image.Frames.Count == 1 ? Array.Empty<TPixel>() : quantized.Palette.ToArray();
+        TPixel[] globalPalette = image.Frames.Count == 1 ? [] : quantized.Palette.ToArray();
 
         this.EncodeAdditionalFrames(stream, image, globalPalette, derivedTransparencyIndex, frameMetadata.DisposalMethod);
 
@@ -488,8 +488,7 @@ internal sealed class GifEncoderCore : IImageEncoderInternals
         int index = -1;
         if (quantized != null)
         {
-            TPixel transparentPixel = default;
-            transparentPixel.FromScaledVector4(Vector4.Zero);
+            TPixel transparentPixel = TPixel.FromScaledVector4(Vector4.Zero);
             ReadOnlySpan<TPixel> palette = quantized.Palette.Span;
 
             // Transparent pixels are much more likely to be found at the end of a palette.
@@ -693,7 +692,7 @@ internal sealed class GifEncoderCore : IImageEncoderInternals
         }
 
         IMemoryOwner<byte>? owner = null;
-        Span<byte> extensionBuffer = stackalloc byte[0]; // workaround compiler limitation
+        scoped Span<byte> extensionBuffer = []; // workaround compiler limitation
         if (extensionSize > 128)
         {
             owner = this.memoryAllocator.Allocate<byte>(extensionSize + 3);
diff --git a/src/ImageSharp/Formats/PixelTypeInfo.cs b/src/ImageSharp/Formats/PixelTypeInfo.cs
deleted file mode 100644
index 1328c6528..000000000
--- a/src/ImageSharp/Formats/PixelTypeInfo.cs
+++ /dev/null
@@ -1,53 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-
-using System.Runtime.CompilerServices;
-using SixLabors.ImageSharp.PixelFormats;
-
-// TODO: Review this class as it's used to represent 2 different things.
-// 1.The encoded image pixel format.
-// 2. The pixel format of the decoded image.
-namespace SixLabors.ImageSharp.Formats;
-
-/// <summary>
-/// Contains information about the pixels that make up an images visual data.
-/// </summary>
-public class PixelTypeInfo
-{
-    /// <summary>
-    /// Initializes a new instance of the <see cref="PixelTypeInfo"/> class.
-    /// </summary>
-    /// <param name="bitsPerPixel">Color depth, in number of bits per pixel.</param>
-    public PixelTypeInfo(int bitsPerPixel)
-        => this.BitsPerPixel = bitsPerPixel;
-
-    /// <summary>
-    /// Initializes a new instance of the <see cref="PixelTypeInfo"/> class.
-    /// </summary>
-    /// <param name="bitsPerPixel">Color depth, in number of bits per pixel.</param>
-    /// <param name="alpha">The pixel alpha transparency behavior.</param>
-    public PixelTypeInfo(int bitsPerPixel, PixelAlphaRepresentation alpha)
-    {
-        this.BitsPerPixel = bitsPerPixel;
-        this.AlphaRepresentation = alpha;
-    }
-
-    /// <summary>
-    /// Gets color depth, in number of bits per pixel.
-    /// </summary>
-    public int BitsPerPixel { get; }
-
-    /// <summary>
-    /// Gets the pixel alpha transparency behavior.
-    /// <see langword="null"/> means unknown, unspecified.
-    /// </summary>
-    public PixelAlphaRepresentation? AlphaRepresentation { get; }
-
-    internal static PixelTypeInfo Create<TPixel>()
-        where TPixel : unmanaged, IPixel<TPixel>
-        => new(Unsafe.SizeOf<TPixel>() * 8);
-
-    internal static PixelTypeInfo Create<TPixel>(PixelAlphaRepresentation alpha)
-        where TPixel : unmanaged, IPixel<TPixel>
-        => new(Unsafe.SizeOf<TPixel>() * 8, alpha);
-}
diff --git a/src/ImageSharp/Formats/Png/PngBitDepth.cs b/src/ImageSharp/Formats/Png/PngBitDepth.cs
index 452839d1d..a5cd2026b 100644
--- a/src/ImageSharp/Formats/Png/PngBitDepth.cs
+++ b/src/ImageSharp/Formats/Png/PngBitDepth.cs
@@ -1,4 +1,4 @@
-// Copyright (c) Six Labors.
+// Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
 // Note the value assignment, This will allow us to add 1, 2, and 4 bit encoding when we support it.
diff --git a/src/ImageSharp/Formats/Png/PngDecoderCore.cs b/src/ImageSharp/Formats/Png/PngDecoderCore.cs
index 3eabbdef0..4178d2820 100644
--- a/src/ImageSharp/Formats/Png/PngDecoderCore.cs
+++ b/src/ImageSharp/Formats/Png/PngDecoderCore.cs
@@ -1240,10 +1240,7 @@ internal sealed class PngDecoderCore : IImageDecoderInternals
 
         Color[] colorTable = new Color[palette.Length / Unsafe.SizeOf<Rgb24>()];
         ReadOnlySpan<Rgb24> rgbTable = MemoryMarshal.Cast<byte, Rgb24>(palette);
-        for (int i = 0; i < colorTable.Length; i++)
-        {
-            colorTable[i] = new Color(rgbTable[i]);
-        }
+        Color.FromPixel(rgbTable, colorTable);
 
         if (alpha.Length > 0)
         {
@@ -1276,14 +1273,14 @@ internal sealed class PngDecoderCore : IImageDecoderInternals
                     ushort gc = BinaryPrimitives.ReadUInt16LittleEndian(alpha.Slice(2, 2));
                     ushort bc = BinaryPrimitives.ReadUInt16LittleEndian(alpha.Slice(4, 2));
 
-                    pngMetadata.TransparentColor = new(new Rgb48(rc, gc, bc));
+                    pngMetadata.TransparentColor = Color.FromPixel(new Rgb48(rc, gc, bc));
                     return;
                 }
 
                 byte r = ReadByteLittleEndian(alpha, 0);
                 byte g = ReadByteLittleEndian(alpha, 2);
                 byte b = ReadByteLittleEndian(alpha, 4);
-                pngMetadata.TransparentColor = new(new Rgb24(r, g, b));
+                pngMetadata.TransparentColor = Color.FromPixel(new Rgb24(r, g, b));
             }
         }
         else if (this.pngColorType == PngColorType.Grayscale)
diff --git a/src/ImageSharp/Formats/Png/PngEncoderCore.cs b/src/ImageSharp/Formats/Png/PngEncoderCore.cs
index e348d7467..993f53269 100644
--- a/src/ImageSharp/Formats/Png/PngEncoderCore.cs
+++ b/src/ImageSharp/Formats/Png/PngEncoderCore.cs
@@ -328,18 +328,17 @@ internal sealed class PngEncoderCore : IImageEncoderInternals, IDisposable
         => clone.ProcessPixelRows(accessor =>
         {
             // TODO: We should be able to speed this up with SIMD and masking.
-            Rgba32 rgba32 = default;
-            Rgba32 transparent = Color.Transparent;
+            Rgba32 transparent = Color.Transparent.ToPixel<Rgba32>();
             for (int y = 0; y < accessor.Height; y++)
             {
                 Span<TPixel> span = accessor.GetRowSpan(y);
                 for (int x = 0; x < accessor.Width; x++)
                 {
-                    span[x].ToRgba32(ref rgba32);
-
-                    if (rgba32.A is 0)
+                    ref TPixel pixel = ref span[x];
+                    Rgba32 rgba = pixel.ToRgba32();
+                    if (rgba.A is 0)
                     {
-                        span[x].FromRgba32(transparent);
+                        pixel = TPixel.FromRgba32(transparent);
                     }
                 }
             }
@@ -1066,7 +1065,7 @@ internal sealed class PngEncoderCore : IImageEncoderInternals, IDisposable
             else
             {
                 alpha.Clear();
-                Rgb24 rgb = pngMetadata.TransparentColor.Value.ToRgb24();
+                Rgb24 rgb = pngMetadata.TransparentColor.Value.ToPixel<Rgb24>();
                 alpha[1] = rgb.R;
                 alpha[3] = rgb.G;
                 alpha[5] = rgb.B;
@@ -1466,23 +1465,48 @@ internal sealed class PngEncoderCore : IImageEncoderInternals, IDisposable
 
         // Use options, then check metadata, if nothing set there then we suggest
         // a sensible default based upon the pixel format.
-        this.colorType = encoder.ColorType ?? pngMetadata.ColorType ?? SuggestColorType<TPixel>();
-        if (!encoder.FilterMethod.HasValue)
+        PngColorType? colorType = encoder.ColorType ?? pngMetadata.ColorType;
+        byte? bits = (byte?)(encoder.BitDepth ?? pngMetadata.BitDepth);
+
+        if (colorType is null || bits is null)
         {
-            // Specification recommends default filter method None for paletted images and Paeth for others.
-            this.filterMethod = this.colorType is PngColorType.Palette ? PngFilterMethod.None : PngFilterMethod.Paeth;
+            PixelTypeInfo info = TPixel.GetPixelTypeInfo();
+            PixelComponentInfo? componentInfo = info.ComponentInfo;
+
+            colorType ??= SuggestColorType<TPixel>(in info);
+
+            if (bits is null)
+            {
+                // TODO: Update once we stop abusing PixelTypeInfo in decoders.
+                if (componentInfo.HasValue)
+                {
+                    PixelComponentInfo c = componentInfo.Value;
+                    bits = (byte)SuggestBitDepth<TPixel>(in c);
+                }
+                else
+                {
+                    bits = (byte)PngBitDepth.Bit8;
+                }
+            }
         }
 
         // Ensure bit depth and color type are a supported combination.
         // Bit8 is the only bit depth supported by all color types.
-        byte bits = (byte)(encoder.BitDepth ?? pngMetadata.BitDepth ?? SuggestBitDepth<TPixel>());
-        byte[] validBitDepths = PngConstants.ColorTypes[this.colorType];
+        byte[] validBitDepths = PngConstants.ColorTypes[colorType.Value];
         if (Array.IndexOf(validBitDepths, bits) == -1)
         {
             bits = (byte)PngBitDepth.Bit8;
         }
 
-        this.bitDepth = bits;
+        this.colorType = colorType.Value;
+        this.bitDepth = bits.Value;
+
+        if (!encoder.FilterMethod.HasValue)
+        {
+            // Specification recommends default filter method None for paletted images and Paeth for others.
+            this.filterMethod = this.colorType is PngColorType.Palette ? PngFilterMethod.None : PngFilterMethod.Paeth;
+        }
+
         use16Bit = bits == (byte)PngBitDepth.Bit16;
         bytesPerPixel = CalculateBytesPerPixel(this.colorType, use16Bit);
 
@@ -1611,53 +1635,44 @@ internal sealed class PngEncoderCore : IImageEncoderInternals, IDisposable
 
     /// <summary>
     /// Returns a suggested <see cref="PngColorType"/> for the given <typeparamref name="TPixel"/>
-    /// This is not exhaustive but covers many common pixel formats.
     /// </summary>
+    /// <param name="info">The pixel type info.</param>
     /// <typeparam name="TPixel">The type of pixel format.</typeparam>
-    private static PngColorType SuggestColorType<TPixel>()
+    private static PngColorType SuggestColorType<TPixel>(in PixelTypeInfo info)
         where TPixel : unmanaged, IPixel<TPixel>
-        => default(TPixel) switch
-        {
-            A8 => PngColorType.GrayscaleWithAlpha,
-            Argb32 => PngColorType.RgbWithAlpha,
-            Bgr24 => PngColorType.Rgb,
-            Bgra32 => PngColorType.RgbWithAlpha,
-            L8 => PngColorType.Grayscale,
-            L16 => PngColorType.Grayscale,
-            La16 => PngColorType.GrayscaleWithAlpha,
-            La32 => PngColorType.GrayscaleWithAlpha,
-            Rgb24 => PngColorType.Rgb,
-            Rgba32 => PngColorType.RgbWithAlpha,
-            Rgb48 => PngColorType.Rgb,
-            Rgba64 => PngColorType.RgbWithAlpha,
-            RgbaVector => PngColorType.RgbWithAlpha,
-            _ => PngColorType.RgbWithAlpha
+    {
+        if (info.AlphaRepresentation == PixelAlphaRepresentation.None)
+        {
+            return info.ColorType switch
+            {
+                PixelColorType.Grayscale => PngColorType.Grayscale,
+                _ => PngColorType.Rgb,
+            };
+        }
+
+        return info.ColorType switch
+        {
+            PixelColorType.Grayscale | PixelColorType.Alpha or PixelColorType.Alpha => PngColorType.GrayscaleWithAlpha,
+            _ => PngColorType.RgbWithAlpha,
         };
+    }
 
     /// <summary>
     /// Returns a suggested <see cref="PngBitDepth"/> for the given <typeparamref name="TPixel"/>
-    /// This is not exhaustive but covers many common pixel formats.
     /// </summary>
+    /// <param name="info">The pixel type info.</param>
     /// <typeparam name="TPixel">The type of pixel format.</typeparam>
-    private static PngBitDepth SuggestBitDepth<TPixel>()
+    private static PngBitDepth SuggestBitDepth<TPixel>(in PixelComponentInfo info)
         where TPixel : unmanaged, IPixel<TPixel>
-        => default(TPixel) switch
-        {
-            A8 => PngBitDepth.Bit8,
-            Argb32 => PngBitDepth.Bit8,
-            Bgr24 => PngBitDepth.Bit8,
-            Bgra32 => PngBitDepth.Bit8,
-            L8 => PngBitDepth.Bit8,
-            L16 => PngBitDepth.Bit16,
-            La16 => PngBitDepth.Bit8,
-            La32 => PngBitDepth.Bit16,
-            Rgb24 => PngBitDepth.Bit8,
-            Rgba32 => PngBitDepth.Bit8,
-            Rgb48 => PngBitDepth.Bit16,
-            Rgba64 => PngBitDepth.Bit16,
-            RgbaVector => PngBitDepth.Bit16,
-            _ => PngBitDepth.Bit8
-        };
+    {
+        int bits = info.GetMaximumComponentPrecision();
+        if (bits > (int)PixelComponentBitDepth.Bit8)
+        {
+            return PngBitDepth.Bit16;
+        }
+
+        return PngBitDepth.Bit8;
+    }
 
     private unsafe struct ScratchBuffer
     {
diff --git a/src/ImageSharp/Formats/Png/PngScanlineProcessor.cs b/src/ImageSharp/Formats/Png/PngScanlineProcessor.cs
index f217515e3..aa937a8e2 100644
--- a/src/ImageSharp/Formats/Png/PngScanlineProcessor.cs
+++ b/src/ImageSharp/Formats/Png/PngScanlineProcessor.cs
@@ -42,7 +42,6 @@ internal static class PngScanlineProcessor
         where TPixel : unmanaged, IPixel<TPixel>
     {
         uint offset = pixelOffset + frameControl.XOffset;
-        TPixel pixel = default;
         ref byte scanlineSpanRef = ref MemoryMarshal.GetReference(scanlineSpan);
         ref TPixel rowSpanRef = ref MemoryMarshal.GetReference(rowSpan);
         int scaleFactor = 255 / (ColorNumerics.GetColorCountForBitDepth(bitDepth) - 1);
@@ -55,8 +54,7 @@ internal static class PngScanlineProcessor
                 for (nuint x = offset; x < frameControl.XMax; x += increment, o += 2)
                 {
                     ushort luminance = BinaryPrimitives.ReadUInt16BigEndian(scanlineSpan.Slice(o, 2));
-                    pixel.FromL16(Unsafe.As<ushort, L16>(ref luminance));
-                    Unsafe.Add(ref rowSpanRef, x) = pixel;
+                    Unsafe.Add(ref rowSpanRef, x) = TPixel.FromL16(Unsafe.As<ushort, L16>(ref luminance));
                 }
             }
             else
@@ -64,8 +62,7 @@ internal static class PngScanlineProcessor
                 for (nuint x = offset, o = 0; x < frameControl.XMax; x += increment, o++)
                 {
                     byte luminance = (byte)(Unsafe.Add(ref scanlineSpanRef, o) * scaleFactor);
-                    pixel.FromL8(Unsafe.As<byte, L8>(ref luminance));
-                    Unsafe.Add(ref rowSpanRef, x) = pixel;
+                    Unsafe.Add(ref rowSpanRef, x) = TPixel.FromL8(Unsafe.As<byte, L8>(ref luminance));
                 }
             }
 
@@ -75,30 +72,22 @@ internal static class PngScanlineProcessor
         if (bitDepth == 16)
         {
             L16 transparent = transparentColor.Value.ToPixel<L16>();
-            La32 source = default;
             int o = 0;
             for (nuint x = offset; x < frameControl.XMax; x += increment, o += 2)
             {
                 ushort luminance = BinaryPrimitives.ReadUInt16BigEndian(scanlineSpan.Slice(o, 2));
-                source.L = luminance;
-                source.A = luminance.Equals(transparent.PackedValue) ? ushort.MinValue : ushort.MaxValue;
-
-                pixel.FromLa32(source);
-                Unsafe.Add(ref rowSpanRef, x) = pixel;
+                La32 source = new(luminance, luminance.Equals(transparent.PackedValue) ? ushort.MinValue : ushort.MaxValue);
+                Unsafe.Add(ref rowSpanRef, x) = TPixel.FromLa32(source);
             }
         }
         else
         {
             byte transparent = (byte)(transparentColor.Value.ToPixel<L8>().PackedValue * scaleFactor);
-            La16 source = default;
             for (nuint x = offset, o = 0; x < frameControl.XMax; x += increment, o++)
             {
                 byte luminance = (byte)(Unsafe.Add(ref scanlineSpanRef, o) * scaleFactor);
-                source.L = luminance;
-                source.A = luminance.Equals(transparent) ? byte.MinValue : byte.MaxValue;
-
-                pixel.FromLa16(source);
-                Unsafe.Add(ref rowSpanRef, x) = pixel;
+                La16 source = new(luminance, luminance.Equals(transparent) ? byte.MinValue : byte.MaxValue);
+                Unsafe.Add(ref rowSpanRef, x) = TPixel.FromLa16(source);
             }
         }
     }
@@ -133,34 +122,28 @@ internal static class PngScanlineProcessor
         where TPixel : unmanaged, IPixel<TPixel>
     {
         uint offset = pixelOffset + frameControl.XOffset;
-        TPixel pixel = default;
         ref byte scanlineSpanRef = ref MemoryMarshal.GetReference(scanlineSpan);
         ref TPixel rowSpanRef = ref MemoryMarshal.GetReference(rowSpan);
 
         if (bitDepth == 16)
         {
-            La32 source = default;
             int o = 0;
             for (nuint x = offset; x < frameControl.XMax; x += increment, o += 4)
             {
-                source.L = BinaryPrimitives.ReadUInt16BigEndian(scanlineSpan.Slice(o, 2));
-                source.A = BinaryPrimitives.ReadUInt16BigEndian(scanlineSpan.Slice(o + 2, 2));
+                ushort l = BinaryPrimitives.ReadUInt16BigEndian(scanlineSpan.Slice(o, 2));
+                ushort a = BinaryPrimitives.ReadUInt16BigEndian(scanlineSpan.Slice(o + 2, 2));
 
-                pixel.FromLa32(source);
-                Unsafe.Add(ref rowSpanRef, (uint)x) = pixel;
+                Unsafe.Add(ref rowSpanRef, (uint)x) = TPixel.FromLa32(new(l, a));
             }
         }
         else
         {
-            La16 source = default;
             nuint offset2 = 0;
             for (nuint x = offset; x < frameControl.XMax; x += increment)
             {
-                source.L = Unsafe.Add(ref scanlineSpanRef, offset2);
-                source.A = Unsafe.Add(ref scanlineSpanRef, offset2 + bytesPerSample);
-
-                pixel.FromLa16(source);
-                Unsafe.Add(ref rowSpanRef, x) = pixel;
+                byte l = Unsafe.Add(ref scanlineSpanRef, offset2);
+                byte a = Unsafe.Add(ref scanlineSpanRef, offset2 + bytesPerSample);
+                Unsafe.Add(ref rowSpanRef, x) = TPixel.FromLa16(new(l, a));
                 offset2 += bytesPerPixel;
             }
         }
@@ -194,7 +177,6 @@ internal static class PngScanlineProcessor
             PngThrowHelper.ThrowMissingPalette();
         }
 
-        TPixel pixel = default;
         ref byte scanlineSpanRef = ref MemoryMarshal.GetReference(scanlineSpan);
         ref TPixel rowSpanRef = ref MemoryMarshal.GetReference(rowSpan);
         ref Color paletteBase = ref MemoryMarshal.GetReference(palette.Value.Span);
@@ -202,8 +184,7 @@ internal static class PngScanlineProcessor
         for (nuint x = pixelOffset, o = 0; x < frameControl.XMax; x += increment, o++)
         {
             uint index = Unsafe.Add(ref scanlineSpanRef, o);
-            pixel.FromRgba32(Unsafe.Add(ref paletteBase, index).ToRgba32());
-            Unsafe.Add(ref rowSpanRef, x) = pixel;
+            Unsafe.Add(ref rowSpanRef, x) = TPixel.FromRgba32(Unsafe.Add(ref paletteBase, index).ToPixel<Rgba32>());
         }
     }
 
@@ -243,8 +224,6 @@ internal static class PngScanlineProcessor
         where TPixel : unmanaged, IPixel<TPixel>
     {
         uint offset = pixelOffset + frameControl.XOffset;
-
-        TPixel pixel = default;
         ref byte scanlineSpanRef = ref MemoryMarshal.GetReference(scanlineSpan);
         ref TPixel rowSpanRef = ref MemoryMarshal.GetReference(rowSpan);
 
@@ -252,16 +231,13 @@ internal static class PngScanlineProcessor
         {
             if (bitDepth == 16)
             {
-                Rgb48 rgb48 = default;
                 int o = 0;
                 for (nuint x = offset; x < frameControl.XMax; x += increment, o += bytesPerPixel)
                 {
-                    rgb48.R = BinaryPrimitives.ReadUInt16BigEndian(scanlineSpan.Slice(o, bytesPerSample));
-                    rgb48.G = BinaryPrimitives.ReadUInt16BigEndian(scanlineSpan.Slice(o + bytesPerSample, bytesPerSample));
-                    rgb48.B = BinaryPrimitives.ReadUInt16BigEndian(scanlineSpan.Slice(o + (2 * bytesPerSample), bytesPerSample));
-
-                    pixel.FromRgb48(rgb48);
-                    Unsafe.Add(ref rowSpanRef, x) = pixel;
+                    ushort r = BinaryPrimitives.ReadUInt16BigEndian(scanlineSpan.Slice(o, bytesPerSample));
+                    ushort g = BinaryPrimitives.ReadUInt16BigEndian(scanlineSpan.Slice(o + bytesPerSample, bytesPerSample));
+                    ushort b = BinaryPrimitives.ReadUInt16BigEndian(scanlineSpan.Slice(o + (2 * bytesPerSample), bytesPerSample));
+                    Unsafe.Add(ref rowSpanRef, x) = TPixel.FromRgb48(new(r, g, b));
                 }
             }
             else if (pixelOffset == 0 && increment == 1)
@@ -274,16 +250,13 @@ internal static class PngScanlineProcessor
             }
             else
             {
-                Rgb24 rgb = default;
                 int o = 0;
                 for (nuint x = offset; x < frameControl.XMax; x += increment, o += bytesPerPixel)
                 {
-                    rgb.R = Unsafe.Add(ref scanlineSpanRef, (uint)o);
-                    rgb.G = Unsafe.Add(ref scanlineSpanRef, (uint)(o + bytesPerSample));
-                    rgb.B = Unsafe.Add(ref scanlineSpanRef, (uint)(o + (2 * bytesPerSample)));
-
-                    pixel.FromRgb24(rgb);
-                    Unsafe.Add(ref rowSpanRef, x) = pixel;
+                    byte r = Unsafe.Add(ref scanlineSpanRef, (uint)o);
+                    byte g = Unsafe.Add(ref scanlineSpanRef, (uint)(o + bytesPerSample));
+                    byte b = Unsafe.Add(ref scanlineSpanRef, (uint)(o + (2 * bytesPerSample)));
+                    Unsafe.Add(ref rowSpanRef, x) = TPixel.FromRgb24(new(r, g, b));
                 }
             }
 
@@ -293,27 +266,20 @@ internal static class PngScanlineProcessor
         if (bitDepth == 16)
         {
             Rgb48 transparent = transparentColor.Value.ToPixel<Rgb48>();
-
-            Rgb48 rgb48 = default;
-            Rgba64 rgba64 = default;
+            Rgba64 rgba = default;
             int o = 0;
             for (nuint x = offset; x < frameControl.XMax; x += increment, o += bytesPerPixel)
             {
-                rgb48.R = BinaryPrimitives.ReadUInt16BigEndian(scanlineSpan.Slice(o, bytesPerSample));
-                rgb48.G = BinaryPrimitives.ReadUInt16BigEndian(scanlineSpan.Slice(o + bytesPerSample, bytesPerSample));
-                rgb48.B = BinaryPrimitives.ReadUInt16BigEndian(scanlineSpan.Slice(o + (2 * bytesPerSample), bytesPerSample));
-
-                rgba64.Rgb = rgb48;
-                rgba64.A = rgb48.Equals(transparent) ? ushort.MinValue : ushort.MaxValue;
-
-                pixel.FromRgba64(rgba64);
-                Unsafe.Add(ref rowSpanRef, x) = pixel;
+                rgba.R = BinaryPrimitives.ReadUInt16BigEndian(scanlineSpan.Slice(o, bytesPerSample));
+                rgba.G = BinaryPrimitives.ReadUInt16BigEndian(scanlineSpan.Slice(o + bytesPerSample, bytesPerSample));
+                rgba.B = BinaryPrimitives.ReadUInt16BigEndian(scanlineSpan.Slice(o + (2 * bytesPerSample), bytesPerSample));
+                rgba.A = rgba.Rgb.Equals(transparent) ? ushort.MinValue : ushort.MaxValue;
+                Unsafe.Add(ref rowSpanRef, x) = TPixel.FromRgba64(rgba);
             }
         }
         else
         {
             Rgb24 transparent = transparentColor.Value.ToPixel<Rgb24>();
-
             Rgba32 rgba = default;
             int o = 0;
             for (nuint x = offset; x < frameControl.XMax; x += increment, o += bytesPerPixel)
@@ -322,9 +288,7 @@ internal static class PngScanlineProcessor
                 rgba.G = Unsafe.Add(ref scanlineSpanRef, (uint)(o + bytesPerSample));
                 rgba.B = Unsafe.Add(ref scanlineSpanRef, (uint)(o + (2 * bytesPerSample)));
                 rgba.A = transparent.Equals(rgba.Rgb) ? byte.MinValue : byte.MaxValue;
-
-                pixel.FromRgba32(rgba);
-                Unsafe.Add(ref rowSpanRef, x) = pixel;
+                Unsafe.Add(ref rowSpanRef, x) = TPixel.FromRgba32(rgba);
             }
         }
     }
@@ -362,22 +326,18 @@ internal static class PngScanlineProcessor
         where TPixel : unmanaged, IPixel<TPixel>
     {
         uint offset = pixelOffset + frameControl.XOffset;
-        TPixel pixel = default;
         ref TPixel rowSpanRef = ref MemoryMarshal.GetReference(rowSpan);
 
         if (bitDepth == 16)
         {
-            Rgba64 rgba64 = default;
             int o = 0;
             for (nuint x = offset; x < frameControl.XMax; x += increment, o += bytesPerPixel)
             {
-                rgba64.R = BinaryPrimitives.ReadUInt16BigEndian(scanlineSpan.Slice(o, bytesPerSample));
-                rgba64.G = BinaryPrimitives.ReadUInt16BigEndian(scanlineSpan.Slice(o + bytesPerSample, bytesPerSample));
-                rgba64.B = BinaryPrimitives.ReadUInt16BigEndian(scanlineSpan.Slice(o + (2 * bytesPerSample), bytesPerSample));
-                rgba64.A = BinaryPrimitives.ReadUInt16BigEndian(scanlineSpan.Slice(o + (3 * bytesPerSample), bytesPerSample));
-
-                pixel.FromRgba64(rgba64);
-                Unsafe.Add(ref rowSpanRef, x) = pixel;
+                ushort r = BinaryPrimitives.ReadUInt16BigEndian(scanlineSpan.Slice(o, bytesPerSample));
+                ushort g = BinaryPrimitives.ReadUInt16BigEndian(scanlineSpan.Slice(o + bytesPerSample, bytesPerSample));
+                ushort b = BinaryPrimitives.ReadUInt16BigEndian(scanlineSpan.Slice(o + (2 * bytesPerSample), bytesPerSample));
+                ushort a = BinaryPrimitives.ReadUInt16BigEndian(scanlineSpan.Slice(o + (3 * bytesPerSample), bytesPerSample));
+                Unsafe.Add(ref rowSpanRef, x) = TPixel.FromRgba64(new(r, g, b, a));
             }
         }
         else if (pixelOffset == 0 && increment == 1)
@@ -391,17 +351,14 @@ internal static class PngScanlineProcessor
         else
         {
             ref byte scanlineSpanRef = ref MemoryMarshal.GetReference(scanlineSpan);
-            Rgba32 rgba = default;
             int o = 0;
             for (nuint x = offset; x < frameControl.XMax; x += increment, o += bytesPerPixel)
             {
-                rgba.R = Unsafe.Add(ref scanlineSpanRef, (uint)o);
-                rgba.G = Unsafe.Add(ref scanlineSpanRef, (uint)(o + bytesPerSample));
-                rgba.B = Unsafe.Add(ref scanlineSpanRef, (uint)(o + (2 * bytesPerSample)));
-                rgba.A = Unsafe.Add(ref scanlineSpanRef, (uint)(o + (3 * bytesPerSample)));
-
-                pixel.FromRgba32(rgba);
-                Unsafe.Add(ref rowSpanRef, x) = pixel;
+                byte r = Unsafe.Add(ref scanlineSpanRef, (uint)o);
+                byte g = Unsafe.Add(ref scanlineSpanRef, (uint)(o + bytesPerSample));
+                byte b = Unsafe.Add(ref scanlineSpanRef, (uint)(o + (2 * bytesPerSample)));
+                byte a = Unsafe.Add(ref scanlineSpanRef, (uint)(o + (3 * bytesPerSample)));
+                Unsafe.Add(ref rowSpanRef, x) = TPixel.FromRgba32(new(r, g, b, a));
             }
         }
     }
diff --git a/src/ImageSharp/Formats/Qoi/QoiDecoderCore.cs b/src/ImageSharp/Formats/Qoi/QoiDecoderCore.cs
index deb0a37f0..86d81d834 100644
--- a/src/ImageSharp/Formats/Qoi/QoiDecoderCore.cs
+++ b/src/ImageSharp/Formats/Qoi/QoiDecoderCore.cs
@@ -149,7 +149,7 @@ internal class QoiDecoderCore : IImageDecoderInternals
         Span<Rgba32> previouslySeenPixels = previouslySeenPixelsBuffer.GetSpan();
         Rgba32 previousPixel = new(0, 0, 0, 255);
 
-        // We save the pixel to avoid loosing the fully opaque black pixel
+        // We save the pixel to avoid losing the fully opaque black pixel
         // See https://github.com/phoboslab/qoi/issues/258
         int pixelArrayPosition = GetArrayPosition(previousPixel);
         previouslySeenPixels[pixelArrayPosition] = previousPixel;
@@ -174,7 +174,7 @@ internal class QoiDecoderCore : IImageDecoderInternals
                         }
 
                         readPixel.A = previousPixel.A;
-                        pixel.FromRgba32(readPixel);
+                        pixel = TPixel.FromRgba32(readPixel);
                         pixelArrayPosition = GetArrayPosition(readPixel);
                         previouslySeenPixels[pixelArrayPosition] = readPixel;
                         break;
@@ -186,7 +186,7 @@ internal class QoiDecoderCore : IImageDecoderInternals
                             ThrowInvalidImageContentException();
                         }
 
-                        pixel.FromRgba32(readPixel);
+                        pixel = TPixel.FromRgba32(readPixel);
                         pixelArrayPosition = GetArrayPosition(readPixel);
                         previouslySeenPixels[pixelArrayPosition] = readPixel;
                         break;
@@ -197,7 +197,7 @@ internal class QoiDecoderCore : IImageDecoderInternals
                             // Getting one pixel from previously seen pixels
                             case QoiChunk.QoiOpIndex:
                                 readPixel = previouslySeenPixels[operationByte];
-                                pixel.FromRgba32(readPixel);
+                                pixel = TPixel.FromRgba32(readPixel);
                                 break;
 
                             // Get one pixel from the difference (-2..1) of the previous pixel
@@ -211,7 +211,7 @@ internal class QoiDecoderCore : IImageDecoderInternals
                                     G = (byte)Numerics.Modulo256(previousPixel.G + (greenDifference - 2)),
                                     B = (byte)Numerics.Modulo256(previousPixel.B + (blueDifference - 2))
                                 };
-                                pixel.FromRgba32(readPixel);
+                                pixel = TPixel.FromRgba32(readPixel);
                                 pixelArrayPosition = GetArrayPosition(readPixel);
                                 previouslySeenPixels[pixelArrayPosition] = readPixel;
                                 break;
@@ -227,7 +227,7 @@ internal class QoiDecoderCore : IImageDecoderInternals
                                 int currentRed = Numerics.Modulo256(diffRedDG - 8 + (diffGreen - 32) + previousPixel.R);
                                 int currentBlue = Numerics.Modulo256(diffBlueDG - 8 + (diffGreen - 32) + previousPixel.B);
                                 readPixel = previousPixel with { R = (byte)currentRed, B = (byte)currentBlue, G = (byte)currentGreen };
-                                pixel.FromRgba32(readPixel);
+                                pixel = TPixel.FromRgba32(readPixel);
                                 pixelArrayPosition = GetArrayPosition(readPixel);
                                 previouslySeenPixels[pixelArrayPosition] = readPixel;
                                 break;
@@ -241,7 +241,7 @@ internal class QoiDecoderCore : IImageDecoderInternals
                                 }
 
                                 readPixel = previousPixel;
-                                pixel.FromRgba32(readPixel);
+                                pixel = TPixel.FromRgba32(readPixel);
                                 for (int k = -1; k < repetitions; k++, j++)
                                 {
                                     if (j == row.Length)
diff --git a/src/ImageSharp/Formats/Tga/TgaDecoderCore.cs b/src/ImageSharp/Formats/Tga/TgaDecoderCore.cs
index 26e057bff..cc13d2a03 100644
--- a/src/ImageSharp/Formats/Tga/TgaDecoderCore.cs
+++ b/src/ImageSharp/Formats/Tga/TgaDecoderCore.cs
@@ -222,7 +222,6 @@ internal sealed class TgaDecoderCore : IImageDecoderInternals
     private void ReadPaletted<TPixel>(BufferedReadStream stream, int width, int height, Buffer2D<TPixel> pixels, Span<byte> palette, int colorMapPixelSizeInBytes, TgaImageOrigin origin)
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        TPixel color = default;
         bool invertX = InvertX(origin);
 
         for (int y = 0; y < height; y++)
@@ -237,14 +236,14 @@ internal sealed class TgaDecoderCore : IImageDecoderInternals
                     {
                         for (int x = width - 1; x >= 0; x--)
                         {
-                            this.ReadPalettedBgra16Pixel(stream, palette, colorMapPixelSizeInBytes, x, color, pixelRow);
+                            this.ReadPalettedBgra16Pixel(stream, palette, colorMapPixelSizeInBytes, x, pixelRow);
                         }
                     }
                     else
                     {
                         for (int x = 0; x < width; x++)
                         {
-                            this.ReadPalettedBgra16Pixel(stream, palette, colorMapPixelSizeInBytes, x, color, pixelRow);
+                            this.ReadPalettedBgra16Pixel(stream, palette, colorMapPixelSizeInBytes, x, pixelRow);
                         }
                     }
 
@@ -255,14 +254,14 @@ internal sealed class TgaDecoderCore : IImageDecoderInternals
                     {
                         for (int x = width - 1; x >= 0; x--)
                         {
-                            ReadPalettedBgr24Pixel(stream, palette, colorMapPixelSizeInBytes, x, color, pixelRow);
+                            ReadPalettedBgr24Pixel(stream, palette, colorMapPixelSizeInBytes, x, pixelRow);
                         }
                     }
                     else
                     {
                         for (int x = 0; x < width; x++)
                         {
-                            ReadPalettedBgr24Pixel(stream, palette, colorMapPixelSizeInBytes, x, color, pixelRow);
+                            ReadPalettedBgr24Pixel(stream, palette, colorMapPixelSizeInBytes, x, pixelRow);
                         }
                     }
 
@@ -273,14 +272,14 @@ internal sealed class TgaDecoderCore : IImageDecoderInternals
                     {
                         for (int x = width - 1; x >= 0; x--)
                         {
-                            ReadPalettedBgra32Pixel(stream, palette, colorMapPixelSizeInBytes, x, color, pixelRow);
+                            ReadPalettedBgra32Pixel(stream, palette, colorMapPixelSizeInBytes, x, pixelRow);
                         }
                     }
                     else
                     {
                         for (int x = 0; x < width; x++)
                         {
-                            ReadPalettedBgra32Pixel(stream, palette, colorMapPixelSizeInBytes, x, color, pixelRow);
+                            ReadPalettedBgra32Pixel(stream, palette, colorMapPixelSizeInBytes, x, pixelRow);
                         }
                     }
 
@@ -319,16 +318,16 @@ internal sealed class TgaDecoderCore : IImageDecoderInternals
                 switch (colorMapPixelSizeInBytes)
                 {
                     case 1:
-                        color.FromL8(Unsafe.As<byte, L8>(ref palette[bufferSpan[idx] * colorMapPixelSizeInBytes]));
+                        color = TPixel.FromL8(Unsafe.As<byte, L8>(ref palette[bufferSpan[idx] * colorMapPixelSizeInBytes]));
                         break;
                     case 2:
-                        this.ReadPalettedBgra16Pixel(palette, bufferSpan[idx], colorMapPixelSizeInBytes, ref color);
+                        color = this.ReadPalettedBgra16Pixel<TPixel>(palette, bufferSpan[idx], colorMapPixelSizeInBytes);
                         break;
                     case 3:
-                        color.FromBgr24(Unsafe.As<byte, Bgr24>(ref palette[bufferSpan[idx] * colorMapPixelSizeInBytes]));
+                        color = TPixel.FromBgr24(Unsafe.As<byte, Bgr24>(ref palette[bufferSpan[idx] * colorMapPixelSizeInBytes]));
                         break;
                     case 4:
-                        color.FromBgra32(Unsafe.As<byte, Bgra32>(ref palette[bufferSpan[idx] * colorMapPixelSizeInBytes]));
+                        color = TPixel.FromBgra32(Unsafe.As<byte, Bgra32>(ref palette[bufferSpan[idx] * colorMapPixelSizeInBytes]));
                         break;
                 }
 
@@ -350,17 +349,15 @@ internal sealed class TgaDecoderCore : IImageDecoderInternals
     private void ReadMonoChrome<TPixel>(BufferedReadStream stream, int width, int height, Buffer2D<TPixel> pixels, TgaImageOrigin origin)
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        bool invertX = InvertX(origin);
-        if (invertX)
+        if (InvertX(origin))
         {
-            TPixel color = default;
             for (int y = 0; y < height; y++)
             {
                 int newY = InvertY(y, height, origin);
                 Span<TPixel> pixelSpan = pixels.DangerousGetRowSpan(newY);
                 for (int x = width - 1; x >= 0; x--)
                 {
-                    ReadL8Pixel(stream, color, x, pixelSpan);
+                    ReadL8Pixel(stream, x, pixelSpan);
                 }
             }
 
@@ -369,8 +366,7 @@ internal sealed class TgaDecoderCore : IImageDecoderInternals
 
         using IMemoryOwner<byte> row = this.memoryAllocator.AllocatePaddedPixelRowBuffer(width, 1, 0);
         Span<byte> rowSpan = row.GetSpan();
-        bool invertY = InvertY(origin);
-        if (invertY)
+        if (InvertY(origin))
         {
             for (int y = height - 1; y >= 0; y--)
             {
@@ -398,7 +394,6 @@ internal sealed class TgaDecoderCore : IImageDecoderInternals
     private void ReadBgra16<TPixel>(BufferedReadStream stream, int width, int height, Buffer2D<TPixel> pixels, TgaImageOrigin origin)
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        TPixel color = default;
         bool invertX = InvertX(origin);
         using IMemoryOwner<byte> row = this.memoryAllocator.AllocatePaddedPixelRowBuffer(width, 2, 0);
         Span<byte> rowSpan = row.GetSpan();
@@ -426,14 +421,12 @@ internal sealed class TgaDecoderCore : IImageDecoderInternals
 
                     if (this.fileHeader.ImageType == TgaImageType.BlackAndWhite)
                     {
-                        color.FromLa16(Unsafe.As<byte, La16>(ref MemoryMarshal.GetReference(scratchBuffer)));
+                        pixelSpan[x] = TPixel.FromLa16(Unsafe.As<byte, La16>(ref MemoryMarshal.GetReference(scratchBuffer)));
                     }
                     else
                     {
-                        color.FromBgra5551(Unsafe.As<byte, Bgra5551>(ref MemoryMarshal.GetReference(scratchBuffer)));
+                        pixelSpan[x] = TPixel.FromBgra5551(Unsafe.As<byte, Bgra5551>(ref MemoryMarshal.GetReference(scratchBuffer)));
                     }
-
-                    pixelSpan[x] = color;
                 }
             }
             else
@@ -477,18 +470,16 @@ internal sealed class TgaDecoderCore : IImageDecoderInternals
     private void ReadBgr24<TPixel>(BufferedReadStream stream, int width, int height, Buffer2D<TPixel> pixels, TgaImageOrigin origin)
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        bool invertX = InvertX(origin);
-        if (invertX)
+        if (InvertX(origin))
         {
             Span<byte> scratchBuffer = stackalloc byte[4];
-            TPixel color = default;
             for (int y = 0; y < height; y++)
             {
                 int newY = InvertY(y, height, origin);
                 Span<TPixel> pixelSpan = pixels.DangerousGetRowSpan(newY);
                 for (int x = width - 1; x >= 0; x--)
                 {
-                    ReadBgr24Pixel(stream, color, x, pixelSpan, scratchBuffer);
+                    ReadBgr24Pixel(stream, x, pixelSpan, scratchBuffer);
                 }
             }
 
@@ -497,9 +488,8 @@ internal sealed class TgaDecoderCore : IImageDecoderInternals
 
         using IMemoryOwner<byte> row = this.memoryAllocator.AllocatePaddedPixelRowBuffer(width, 3, 0);
         Span<byte> rowSpan = row.GetSpan();
-        bool invertY = InvertY(origin);
 
-        if (invertY)
+        if (InvertY(origin))
         {
             for (int y = height - 1; y >= 0; y--)
             {
@@ -527,7 +517,6 @@ internal sealed class TgaDecoderCore : IImageDecoderInternals
     private void ReadBgra32<TPixel>(BufferedReadStream stream, int width, int height, Buffer2D<TPixel> pixels, TgaImageOrigin origin)
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        TPixel color = default;
         bool invertX = InvertX(origin);
 
         Guard.NotNull(this.tgaMetadata);
@@ -565,14 +554,14 @@ internal sealed class TgaDecoderCore : IImageDecoderInternals
             {
                 for (int x = width - 1; x >= 0; x--)
                 {
-                    this.ReadBgra32Pixel(stream, x, color, pixelRow, scratchBuffer);
+                    this.ReadBgra32Pixel(stream, x, pixelRow, scratchBuffer);
                 }
             }
             else
             {
                 for (int x = 0; x < width; x++)
                 {
-                    this.ReadBgra32Pixel(stream, x, color, pixelRow, scratchBuffer);
+                    this.ReadBgra32Pixel(stream, x, pixelRow, scratchBuffer);
                 }
             }
         }
@@ -610,7 +599,7 @@ internal sealed class TgaDecoderCore : IImageDecoderInternals
                 switch (bytesPerPixel)
                 {
                     case 1:
-                        color.FromL8(Unsafe.As<byte, L8>(ref bufferSpan[idx]));
+                        color = TPixel.FromL8(Unsafe.As<byte, L8>(ref bufferSpan[idx]));
                         break;
                     case 2:
                         if (!this.hasAlpha)
@@ -621,26 +610,26 @@ internal sealed class TgaDecoderCore : IImageDecoderInternals
 
                         if (this.fileHeader.ImageType == TgaImageType.RleBlackAndWhite)
                         {
-                            color.FromLa16(Unsafe.As<byte, La16>(ref bufferSpan[idx]));
+                            color = TPixel.FromLa16(Unsafe.As<byte, La16>(ref bufferSpan[idx]));
                         }
                         else
                         {
-                            color.FromBgra5551(Unsafe.As<byte, Bgra5551>(ref bufferSpan[idx]));
+                            color = TPixel.FromBgra5551(Unsafe.As<byte, Bgra5551>(ref bufferSpan[idx]));
                         }
 
                         break;
                     case 3:
-                        color.FromBgr24(Unsafe.As<byte, Bgr24>(ref bufferSpan[idx]));
+                        color = TPixel.FromBgr24(Unsafe.As<byte, Bgr24>(ref bufferSpan[idx]));
                         break;
                     case 4:
                         if (this.hasAlpha)
                         {
-                            color.FromBgra32(Unsafe.As<byte, Bgra32>(ref bufferSpan[idx]));
+                            color = TPixel.FromBgra32(Unsafe.As<byte, Bgra32>(ref bufferSpan[idx]));
                         }
                         else
                         {
                             byte alpha = alphaBits == 0 ? byte.MaxValue : bufferSpan[idx + 3];
-                            color.FromBgra32(new Bgra32(bufferSpan[idx + 2], bufferSpan[idx + 1], bufferSpan[idx], alpha));
+                            color = TPixel.FromBgra32(new Bgra32(bufferSpan[idx + 2], bufferSpan[idx + 1], bufferSpan[idx], alpha));
                         }
 
                         break;
@@ -677,16 +666,15 @@ internal sealed class TgaDecoderCore : IImageDecoderInternals
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static void ReadL8Pixel<TPixel>(BufferedReadStream stream, TPixel color, int x, Span<TPixel> pixelSpan)
+    private static void ReadL8Pixel<TPixel>(BufferedReadStream stream, int x, Span<TPixel> pixelSpan)
         where TPixel : unmanaged, IPixel<TPixel>
     {
         byte pixelValue = (byte)stream.ReadByte();
-        color.FromL8(Unsafe.As<byte, L8>(ref pixelValue));
-        pixelSpan[x] = color;
+        pixelSpan[x] = TPixel.FromL8(Unsafe.As<byte, L8>(ref pixelValue));
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static void ReadBgr24Pixel<TPixel>(BufferedReadStream stream, TPixel color, int x, Span<TPixel> pixelSpan, Span<byte> scratchBuffer)
+    private static void ReadBgr24Pixel<TPixel>(BufferedReadStream stream, int x, Span<TPixel> pixelSpan, Span<byte> scratchBuffer)
         where TPixel : unmanaged, IPixel<TPixel>
     {
         int bytesRead = stream.Read(scratchBuffer, 0, 3);
@@ -695,8 +683,7 @@ internal sealed class TgaDecoderCore : IImageDecoderInternals
             TgaThrowHelper.ThrowInvalidImageContentException("Not enough data to read a bgr pixel");
         }
 
-        color.FromBgr24(Unsafe.As<byte, Bgr24>(ref MemoryMarshal.GetReference(scratchBuffer)));
-        pixelSpan[x] = color;
+        pixelSpan[x] = TPixel.FromBgr24(Unsafe.As<byte, Bgr24>(ref MemoryMarshal.GetReference(scratchBuffer)));
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -714,7 +701,7 @@ internal sealed class TgaDecoderCore : IImageDecoderInternals
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private void ReadBgra32Pixel<TPixel>(BufferedReadStream stream, int x, TPixel color, Span<TPixel> pixelRow, Span<byte> scratchBuffer)
+    private void ReadBgra32Pixel<TPixel>(BufferedReadStream stream, int x, Span<TPixel> pixelRow, Span<byte> scratchBuffer)
         where TPixel : unmanaged, IPixel<TPixel>
     {
         int bytesRead = stream.Read(scratchBuffer, 0, 4);
@@ -726,8 +713,7 @@ internal sealed class TgaDecoderCore : IImageDecoderInternals
         Guard.NotNull(this.tgaMetadata);
 
         byte alpha = this.tgaMetadata.AlphaChannelBits == 0 ? byte.MaxValue : scratchBuffer[3];
-        color.FromBgra32(new Bgra32(scratchBuffer[2], scratchBuffer[1], scratchBuffer[0], alpha));
-        pixelRow[x] = color;
+        pixelRow[x] = TPixel.FromBgra32(new Bgra32(scratchBuffer[2], scratchBuffer[1], scratchBuffer[0], alpha));
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -745,7 +731,7 @@ internal sealed class TgaDecoderCore : IImageDecoderInternals
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private void ReadPalettedBgra16Pixel<TPixel>(BufferedReadStream stream, Span<byte> palette, int colorMapPixelSizeInBytes, int x, TPixel color, Span<TPixel> pixelRow)
+    private void ReadPalettedBgra16Pixel<TPixel>(BufferedReadStream stream, Span<byte> palette, int colorMapPixelSizeInBytes, int x, Span<TPixel> pixelRow)
         where TPixel : unmanaged, IPixel<TPixel>
     {
         int colorIndex = stream.ReadByte();
@@ -754,16 +740,14 @@ internal sealed class TgaDecoderCore : IImageDecoderInternals
             TgaThrowHelper.ThrowInvalidImageContentException("Not enough data to read color index");
         }
 
-        this.ReadPalettedBgra16Pixel(palette, colorIndex, colorMapPixelSizeInBytes, ref color);
-        pixelRow[x] = color;
+        pixelRow[x] = this.ReadPalettedBgra16Pixel<TPixel>(palette, colorIndex, colorMapPixelSizeInBytes);
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private void ReadPalettedBgra16Pixel<TPixel>(Span<byte> palette, int index, int colorMapPixelSizeInBytes, ref TPixel color)
+    private TPixel ReadPalettedBgra16Pixel<TPixel>(Span<byte> palette, int index, int colorMapPixelSizeInBytes)
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        Bgra5551 bgra = default;
-        bgra.FromBgra5551(Unsafe.As<byte, Bgra5551>(ref palette[index * colorMapPixelSizeInBytes]));
+        Bgra5551 bgra = Unsafe.As<byte, Bgra5551>(ref palette[index * colorMapPixelSizeInBytes]);
 
         if (!this.hasAlpha)
         {
@@ -771,11 +755,11 @@ internal sealed class TgaDecoderCore : IImageDecoderInternals
             bgra.PackedValue = (ushort)(bgra.PackedValue | 0x8000);
         }
 
-        color.FromBgra5551(bgra);
+        return TPixel.FromBgra5551(bgra);
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static void ReadPalettedBgr24Pixel<TPixel>(BufferedReadStream stream, Span<byte> palette, int colorMapPixelSizeInBytes, int x, TPixel color, Span<TPixel> pixelRow)
+    private static void ReadPalettedBgr24Pixel<TPixel>(BufferedReadStream stream, Span<byte> palette, int colorMapPixelSizeInBytes, int x, Span<TPixel> pixelRow)
         where TPixel : unmanaged, IPixel<TPixel>
     {
         int colorIndex = stream.ReadByte();
@@ -784,12 +768,11 @@ internal sealed class TgaDecoderCore : IImageDecoderInternals
             TgaThrowHelper.ThrowInvalidImageContentException("Not enough data to read color index");
         }
 
-        color.FromBgr24(Unsafe.As<byte, Bgr24>(ref palette[colorIndex * colorMapPixelSizeInBytes]));
-        pixelRow[x] = color;
+        pixelRow[x] = TPixel.FromBgr24(Unsafe.As<byte, Bgr24>(ref palette[colorIndex * colorMapPixelSizeInBytes]));
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static void ReadPalettedBgra32Pixel<TPixel>(BufferedReadStream stream, Span<byte> palette, int colorMapPixelSizeInBytes, int x, TPixel color, Span<TPixel> pixelRow)
+    private static void ReadPalettedBgra32Pixel<TPixel>(BufferedReadStream stream, Span<byte> palette, int colorMapPixelSizeInBytes, int x, Span<TPixel> pixelRow)
         where TPixel : unmanaged, IPixel<TPixel>
     {
         int colorIndex = stream.ReadByte();
@@ -798,8 +781,7 @@ internal sealed class TgaDecoderCore : IImageDecoderInternals
             TgaThrowHelper.ThrowInvalidImageContentException("Not enough data to read color index");
         }
 
-        color.FromBgra32(Unsafe.As<byte, Bgra32>(ref palette[colorIndex * colorMapPixelSizeInBytes]));
-        pixelRow[x] = color;
+        pixelRow[x] = TPixel.FromBgra32(Unsafe.As<byte, Bgra32>(ref palette[colorIndex * colorMapPixelSizeInBytes]));
     }
 
     /// <summary>
@@ -937,7 +919,9 @@ internal sealed class TgaDecoderCore : IImageDecoderInternals
         this.tgaMetadata = this.metadata.GetTgaMetadata();
         this.tgaMetadata.BitsPerPixel = (TgaBitsPerPixel)this.fileHeader.PixelDepth;
 
-        int alphaBits = this.fileHeader.ImageDescriptor & 0xf;
+        // TrueColor images with 32 bits per pixel are assumed to always have 8 bit alpha channel,
+        // because some encoders do not set correctly the alpha bits in the image descriptor.
+        int alphaBits = this.IsTrueColor32BitPerPixel(this.tgaMetadata.BitsPerPixel) ? 8 : this.fileHeader.ImageDescriptor & 0xf;
         if (alphaBits is not 0 and not 1 and not 8)
         {
             TgaThrowHelper.ThrowInvalidImageContentException("Invalid alpha channel bits");
@@ -949,4 +933,8 @@ internal sealed class TgaDecoderCore : IImageDecoderInternals
         // Bits 4 and 5 describe the image origin.
         return (TgaImageOrigin)((this.fileHeader.ImageDescriptor & 0x30) >> 4);
     }
+
+    private bool IsTrueColor32BitPerPixel(TgaBitsPerPixel bitsPerPixel) => bitsPerPixel == TgaBitsPerPixel.Pixel32 &&
+                                                                           (this.fileHeader.ImageType == TgaImageType.TrueColor ||
+                                                                            this.fileHeader.ImageType == TgaImageType.RleTrueColor);
 }
diff --git a/src/ImageSharp/Formats/Tga/TgaEncoderCore.cs b/src/ImageSharp/Formats/Tga/TgaEncoderCore.cs
index bbb476c01..bb13798c5 100644
--- a/src/ImageSharp/Formats/Tga/TgaEncoderCore.cs
+++ b/src/ImageSharp/Formats/Tga/TgaEncoderCore.cs
@@ -5,7 +5,6 @@ using System.Buffers;
 using System.Buffers.Binary;
 using System.Numerics;
 using System.Runtime.CompilerServices;
-using SixLabors.ImageSharp.Advanced;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.Metadata;
 using SixLabors.ImageSharp.PixelFormats;
@@ -160,7 +159,6 @@ internal sealed class TgaEncoderCore : IImageEncoderInternals
     private void WriteRunLengthEncodedImage<TPixel>(Stream stream, ImageFrame<TPixel> image)
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        Rgba32 color = default;
         Buffer2D<TPixel> pixels = image.PixelBuffer;
         for (int y = 0; y < image.Height; y++)
         {
@@ -168,14 +166,13 @@ internal sealed class TgaEncoderCore : IImageEncoderInternals
             for (int x = 0; x < image.Width;)
             {
                 TPixel currentPixel = pixelRow[x];
-                currentPixel.ToRgba32(ref color);
                 byte equalPixelCount = FindEqualPixels(pixelRow, x);
 
                 if (equalPixelCount > 0)
                 {
                     // Write the number of equal pixels, with the high bit set, indicating ist a compressed pixel run.
                     stream.WriteByte((byte)(equalPixelCount | 128));
-                    this.WritePixel(stream, currentPixel, color);
+                    this.WritePixel(stream, currentPixel, currentPixel.ToRgba32());
                     x += equalPixelCount + 1;
                 }
                 else
@@ -183,13 +180,12 @@ internal sealed class TgaEncoderCore : IImageEncoderInternals
                     // Write Raw Packet (i.e., Non-Run-Length Encoded):
                     byte unEqualPixelCount = FindUnEqualPixels(pixelRow, x);
                     stream.WriteByte(unEqualPixelCount);
-                    this.WritePixel(stream, currentPixel, color);
+                    this.WritePixel(stream, currentPixel, currentPixel.ToRgba32());
                     x++;
                     for (int i = 0; i < unEqualPixelCount; i++)
                     {
                         currentPixel = pixelRow[x];
-                        currentPixel.ToRgba32(ref color);
-                        this.WritePixel(stream, currentPixel, color);
+                        this.WritePixel(stream, currentPixel, currentPixel.ToRgba32());
                         x++;
                     }
                 }
diff --git a/src/ImageSharp/Formats/Tga/TgaFileHeader.cs b/src/ImageSharp/Formats/Tga/TgaFileHeader.cs
index 007dc03de..2613cd610 100644
--- a/src/ImageSharp/Formats/Tga/TgaFileHeader.cs
+++ b/src/ImageSharp/Formats/Tga/TgaFileHeader.cs
@@ -131,10 +131,7 @@ internal readonly struct TgaFileHeader
     /// </summary>
     public byte ImageDescriptor { get; }
 
-    public static TgaFileHeader Parse(Span<byte> data)
-    {
-        return MemoryMarshal.Cast<byte, TgaFileHeader>(data)[0];
-    }
+    public static TgaFileHeader Parse(Span<byte> data) => MemoryMarshal.Cast<byte, TgaFileHeader>(data)[0];
 
     public void WriteTo(Span<byte> buffer)
     {
diff --git a/src/ImageSharp/Formats/Tiff/Compression/HorizontalPredictor.cs b/src/ImageSharp/Formats/Tiff/Compression/HorizontalPredictor.cs
index 1c838b0b7..30a933528 100644
--- a/src/ImageSharp/Formats/Tiff/Compression/HorizontalPredictor.cs
+++ b/src/ImageSharp/Formats/Tiff/Compression/HorizontalPredictor.cs
@@ -102,8 +102,7 @@ internal static class HorizontalPredictor
                 byte r = (byte)(rowRgb[x].R - rowRgb[x - 1].R);
                 byte g = (byte)(rowRgb[x].G - rowRgb[x - 1].G);
                 byte b = (byte)(rowRgb[x].B - rowRgb[x - 1].B);
-                var rgb = new Rgb24(r, g, b);
-                rowRgb[x].FromRgb24(rgb);
+                rowRgb[x] = new Rgb24(r, g, b);
             }
         }
     }
@@ -128,8 +127,7 @@ internal static class HorizontalPredictor
 
             for (int x = rowL16.Length - 1; x >= 1; x--)
             {
-                ushort val = (ushort)(rowL16[x].PackedValue - rowL16[x - 1].PackedValue);
-                rowL16[x].PackedValue = val;
+                rowL16[x].PackedValue = (ushort)(rowL16[x].PackedValue - rowL16[x - 1].PackedValue);
             }
         }
     }
@@ -181,13 +179,13 @@ internal static class HorizontalPredictor
             {
                 int offset = 0;
                 Span<byte> rowBytes = pixelBytes.Slice(y * rowBytesCount, rowBytesCount);
-                ushort pixelValue = TiffUtils.ConvertToUShortBigEndian(rowBytes.Slice(offset, 2));
+                ushort pixelValue = TiffUtilities.ConvertToUShortBigEndian(rowBytes.Slice(offset, 2));
                 offset += 2;
 
                 for (int x = 1; x < width; x++)
                 {
                     Span<byte> rowSpan = rowBytes.Slice(offset, 2);
-                    ushort diff = TiffUtils.ConvertToUShortBigEndian(rowSpan);
+                    ushort diff = TiffUtilities.ConvertToUShortBigEndian(rowSpan);
                     pixelValue += diff;
                     BinaryPrimitives.WriteUInt16BigEndian(rowSpan, pixelValue);
                     offset += 2;
@@ -200,13 +198,13 @@ internal static class HorizontalPredictor
             {
                 int offset = 0;
                 Span<byte> rowBytes = pixelBytes.Slice(y * rowBytesCount, rowBytesCount);
-                ushort pixelValue = TiffUtils.ConvertToUShortLittleEndian(rowBytes.Slice(offset, 2));
+                ushort pixelValue = TiffUtilities.ConvertToUShortLittleEndian(rowBytes.Slice(offset, 2));
                 offset += 2;
 
                 for (int x = 1; x < width; x++)
                 {
                     Span<byte> rowSpan = rowBytes.Slice(offset, 2);
-                    ushort diff = TiffUtils.ConvertToUShortLittleEndian(rowSpan);
+                    ushort diff = TiffUtilities.ConvertToUShortLittleEndian(rowSpan);
                     pixelValue += diff;
                     BinaryPrimitives.WriteUInt16LittleEndian(rowSpan, pixelValue);
                     offset += 2;
@@ -225,13 +223,13 @@ internal static class HorizontalPredictor
             {
                 int offset = 0;
                 Span<byte> rowBytes = pixelBytes.Slice(y * rowBytesCount, rowBytesCount);
-                uint pixelValue = TiffUtils.ConvertToUIntBigEndian(rowBytes.Slice(offset, 4));
+                uint pixelValue = TiffUtilities.ConvertToUIntBigEndian(rowBytes.Slice(offset, 4));
                 offset += 4;
 
                 for (int x = 1; x < width; x++)
                 {
                     Span<byte> rowSpan = rowBytes.Slice(offset, 4);
-                    uint diff = TiffUtils.ConvertToUIntBigEndian(rowSpan);
+                    uint diff = TiffUtilities.ConvertToUIntBigEndian(rowSpan);
                     pixelValue += diff;
                     BinaryPrimitives.WriteUInt32BigEndian(rowSpan, pixelValue);
                     offset += 4;
@@ -244,13 +242,13 @@ internal static class HorizontalPredictor
             {
                 int offset = 0;
                 Span<byte> rowBytes = pixelBytes.Slice(y * rowBytesCount, rowBytesCount);
-                uint pixelValue = TiffUtils.ConvertToUIntLittleEndian(rowBytes.Slice(offset, 4));
+                uint pixelValue = TiffUtilities.ConvertToUIntLittleEndian(rowBytes.Slice(offset, 4));
                 offset += 4;
 
                 for (int x = 1; x < width; x++)
                 {
                     Span<byte> rowSpan = rowBytes.Slice(offset, 4);
-                    uint diff = TiffUtils.ConvertToUIntLittleEndian(rowSpan);
+                    uint diff = TiffUtilities.ConvertToUIntLittleEndian(rowSpan);
                     pixelValue += diff;
                     BinaryPrimitives.WriteUInt32LittleEndian(rowSpan, pixelValue);
                     offset += 4;
@@ -278,8 +276,7 @@ internal static class HorizontalPredictor
                 r += pixel.R;
                 g += pixel.G;
                 b += pixel.B;
-                var rgb = new Rgb24(r, g, b);
-                pixel.FromRgb24(rgb);
+                pixel = new Rgb24(r, g, b);
             }
         }
     }
@@ -305,8 +302,7 @@ internal static class HorizontalPredictor
                 g += pixel.G;
                 b += pixel.B;
                 a += pixel.A;
-                var rgb = new Rgba32(r, g, b, a);
-                pixel.FromRgba32(rgb);
+                pixel = new Rgba32(r, g, b, a);
             }
         }
     }
@@ -321,29 +317,29 @@ internal static class HorizontalPredictor
             {
                 int offset = 0;
                 Span<byte> rowBytes = pixelBytes.Slice(y * rowBytesCount, rowBytesCount);
-                ushort r = TiffUtils.ConvertToUShortBigEndian(rowBytes.Slice(offset, 2));
+                ushort r = TiffUtilities.ConvertToUShortBigEndian(rowBytes.Slice(offset, 2));
                 offset += 2;
-                ushort g = TiffUtils.ConvertToUShortBigEndian(rowBytes.Slice(offset, 2));
+                ushort g = TiffUtilities.ConvertToUShortBigEndian(rowBytes.Slice(offset, 2));
                 offset += 2;
-                ushort b = TiffUtils.ConvertToUShortBigEndian(rowBytes.Slice(offset, 2));
+                ushort b = TiffUtilities.ConvertToUShortBigEndian(rowBytes.Slice(offset, 2));
                 offset += 2;
 
                 for (int x = 1; x < width; x++)
                 {
                     Span<byte> rowSpan = rowBytes.Slice(offset, 2);
-                    ushort deltaR = TiffUtils.ConvertToUShortBigEndian(rowSpan);
+                    ushort deltaR = TiffUtilities.ConvertToUShortBigEndian(rowSpan);
                     r += deltaR;
                     BinaryPrimitives.WriteUInt16BigEndian(rowSpan, r);
                     offset += 2;
 
                     rowSpan = rowBytes.Slice(offset, 2);
-                    ushort deltaG = TiffUtils.ConvertToUShortBigEndian(rowSpan);
+                    ushort deltaG = TiffUtilities.ConvertToUShortBigEndian(rowSpan);
                     g += deltaG;
                     BinaryPrimitives.WriteUInt16BigEndian(rowSpan, g);
                     offset += 2;
 
                     rowSpan = rowBytes.Slice(offset, 2);
-                    ushort deltaB = TiffUtils.ConvertToUShortBigEndian(rowSpan);
+                    ushort deltaB = TiffUtilities.ConvertToUShortBigEndian(rowSpan);
                     b += deltaB;
                     BinaryPrimitives.WriteUInt16BigEndian(rowSpan, b);
                     offset += 2;
@@ -356,29 +352,29 @@ internal static class HorizontalPredictor
             {
                 int offset = 0;
                 Span<byte> rowBytes = pixelBytes.Slice(y * rowBytesCount, rowBytesCount);
-                ushort r = TiffUtils.ConvertToUShortLittleEndian(rowBytes.Slice(offset, 2));
+                ushort r = TiffUtilities.ConvertToUShortLittleEndian(rowBytes.Slice(offset, 2));
                 offset += 2;
-                ushort g = TiffUtils.ConvertToUShortLittleEndian(rowBytes.Slice(offset, 2));
+                ushort g = TiffUtilities.ConvertToUShortLittleEndian(rowBytes.Slice(offset, 2));
                 offset += 2;
-                ushort b = TiffUtils.ConvertToUShortLittleEndian(rowBytes.Slice(offset, 2));
+                ushort b = TiffUtilities.ConvertToUShortLittleEndian(rowBytes.Slice(offset, 2));
                 offset += 2;
 
                 for (int x = 1; x < width; x++)
                 {
                     Span<byte> rowSpan = rowBytes.Slice(offset, 2);
-                    ushort deltaR = TiffUtils.ConvertToUShortLittleEndian(rowSpan);
+                    ushort deltaR = TiffUtilities.ConvertToUShortLittleEndian(rowSpan);
                     r += deltaR;
                     BinaryPrimitives.WriteUInt16LittleEndian(rowSpan, r);
                     offset += 2;
 
                     rowSpan = rowBytes.Slice(offset, 2);
-                    ushort deltaG = TiffUtils.ConvertToUShortLittleEndian(rowSpan);
+                    ushort deltaG = TiffUtilities.ConvertToUShortLittleEndian(rowSpan);
                     g += deltaG;
                     BinaryPrimitives.WriteUInt16LittleEndian(rowSpan, g);
                     offset += 2;
 
                     rowSpan = rowBytes.Slice(offset, 2);
-                    ushort deltaB = TiffUtils.ConvertToUShortLittleEndian(rowSpan);
+                    ushort deltaB = TiffUtilities.ConvertToUShortLittleEndian(rowSpan);
                     b += deltaB;
                     BinaryPrimitives.WriteUInt16LittleEndian(rowSpan, b);
                     offset += 2;
@@ -397,37 +393,37 @@ internal static class HorizontalPredictor
             {
                 int offset = 0;
                 Span<byte> rowBytes = pixelBytes.Slice(y * rowBytesCount, rowBytesCount);
-                ushort r = TiffUtils.ConvertToUShortBigEndian(rowBytes.Slice(offset, 2));
+                ushort r = TiffUtilities.ConvertToUShortBigEndian(rowBytes.Slice(offset, 2));
                 offset += 2;
-                ushort g = TiffUtils.ConvertToUShortBigEndian(rowBytes.Slice(offset, 2));
+                ushort g = TiffUtilities.ConvertToUShortBigEndian(rowBytes.Slice(offset, 2));
                 offset += 2;
-                ushort b = TiffUtils.ConvertToUShortBigEndian(rowBytes.Slice(offset, 2));
+                ushort b = TiffUtilities.ConvertToUShortBigEndian(rowBytes.Slice(offset, 2));
                 offset += 2;
-                ushort a = TiffUtils.ConvertToUShortBigEndian(rowBytes.Slice(offset, 2));
+                ushort a = TiffUtilities.ConvertToUShortBigEndian(rowBytes.Slice(offset, 2));
                 offset += 2;
 
                 for (int x = 1; x < width; x++)
                 {
                     Span<byte> rowSpan = rowBytes.Slice(offset, 2);
-                    ushort deltaR = TiffUtils.ConvertToUShortBigEndian(rowSpan);
+                    ushort deltaR = TiffUtilities.ConvertToUShortBigEndian(rowSpan);
                     r += deltaR;
                     BinaryPrimitives.WriteUInt16BigEndian(rowSpan, r);
                     offset += 2;
 
                     rowSpan = rowBytes.Slice(offset, 2);
-                    ushort deltaG = TiffUtils.ConvertToUShortBigEndian(rowSpan);
+                    ushort deltaG = TiffUtilities.ConvertToUShortBigEndian(rowSpan);
                     g += deltaG;
                     BinaryPrimitives.WriteUInt16BigEndian(rowSpan, g);
                     offset += 2;
 
                     rowSpan = rowBytes.Slice(offset, 2);
-                    ushort deltaB = TiffUtils.ConvertToUShortBigEndian(rowSpan);
+                    ushort deltaB = TiffUtilities.ConvertToUShortBigEndian(rowSpan);
                     b += deltaB;
                     BinaryPrimitives.WriteUInt16BigEndian(rowSpan, b);
                     offset += 2;
 
                     rowSpan = rowBytes.Slice(offset, 2);
-                    ushort deltaA = TiffUtils.ConvertToUShortBigEndian(rowSpan);
+                    ushort deltaA = TiffUtilities.ConvertToUShortBigEndian(rowSpan);
                     a += deltaA;
                     BinaryPrimitives.WriteUInt16BigEndian(rowSpan, a);
                     offset += 2;
@@ -440,37 +436,37 @@ internal static class HorizontalPredictor
             {
                 int offset = 0;
                 Span<byte> rowBytes = pixelBytes.Slice(y * rowBytesCount, rowBytesCount);
-                ushort r = TiffUtils.ConvertToUShortLittleEndian(rowBytes.Slice(offset, 2));
+                ushort r = TiffUtilities.ConvertToUShortLittleEndian(rowBytes.Slice(offset, 2));
                 offset += 2;
-                ushort g = TiffUtils.ConvertToUShortLittleEndian(rowBytes.Slice(offset, 2));
+                ushort g = TiffUtilities.ConvertToUShortLittleEndian(rowBytes.Slice(offset, 2));
                 offset += 2;
-                ushort b = TiffUtils.ConvertToUShortLittleEndian(rowBytes.Slice(offset, 2));
+                ushort b = TiffUtilities.ConvertToUShortLittleEndian(rowBytes.Slice(offset, 2));
                 offset += 2;
-                ushort a = TiffUtils.ConvertToUShortLittleEndian(rowBytes.Slice(offset, 2));
+                ushort a = TiffUtilities.ConvertToUShortLittleEndian(rowBytes.Slice(offset, 2));
                 offset += 2;
 
                 for (int x = 1; x < width; x++)
                 {
                     Span<byte> rowSpan = rowBytes.Slice(offset, 2);
-                    ushort deltaR = TiffUtils.ConvertToUShortLittleEndian(rowSpan);
+                    ushort deltaR = TiffUtilities.ConvertToUShortLittleEndian(rowSpan);
                     r += deltaR;
                     BinaryPrimitives.WriteUInt16LittleEndian(rowSpan, r);
                     offset += 2;
 
                     rowSpan = rowBytes.Slice(offset, 2);
-                    ushort deltaG = TiffUtils.ConvertToUShortLittleEndian(rowSpan);
+                    ushort deltaG = TiffUtilities.ConvertToUShortLittleEndian(rowSpan);
                     g += deltaG;
                     BinaryPrimitives.WriteUInt16LittleEndian(rowSpan, g);
                     offset += 2;
 
                     rowSpan = rowBytes.Slice(offset, 2);
-                    ushort deltaB = TiffUtils.ConvertToUShortLittleEndian(rowSpan);
+                    ushort deltaB = TiffUtilities.ConvertToUShortLittleEndian(rowSpan);
                     b += deltaB;
                     BinaryPrimitives.WriteUInt16LittleEndian(rowSpan, b);
                     offset += 2;
 
                     rowSpan = rowBytes.Slice(offset, 2);
-                    ushort deltaA = TiffUtils.ConvertToUShortLittleEndian(rowSpan);
+                    ushort deltaA = TiffUtilities.ConvertToUShortLittleEndian(rowSpan);
                     a += deltaA;
                     BinaryPrimitives.WriteUInt16LittleEndian(rowSpan, a);
                     offset += 2;
@@ -489,29 +485,29 @@ internal static class HorizontalPredictor
             {
                 int offset = 0;
                 Span<byte> rowBytes = pixelBytes.Slice(y * rowBytesCount, rowBytesCount);
-                uint r = TiffUtils.ConvertToUIntBigEndian(rowBytes.Slice(offset, 4));
+                uint r = TiffUtilities.ConvertToUIntBigEndian(rowBytes.Slice(offset, 4));
                 offset += 4;
-                uint g = TiffUtils.ConvertToUIntBigEndian(rowBytes.Slice(offset, 4));
+                uint g = TiffUtilities.ConvertToUIntBigEndian(rowBytes.Slice(offset, 4));
                 offset += 4;
-                uint b = TiffUtils.ConvertToUIntBigEndian(rowBytes.Slice(offset, 4));
+                uint b = TiffUtilities.ConvertToUIntBigEndian(rowBytes.Slice(offset, 4));
                 offset += 4;
 
                 for (int x = 1; x < width; x++)
                 {
                     Span<byte> rowSpan = rowBytes.Slice(offset, 4);
-                    uint deltaR = TiffUtils.ConvertToUIntBigEndian(rowSpan);
+                    uint deltaR = TiffUtilities.ConvertToUIntBigEndian(rowSpan);
                     r += deltaR;
                     BinaryPrimitives.WriteUInt32BigEndian(rowSpan, r);
                     offset += 4;
 
                     rowSpan = rowBytes.Slice(offset, 4);
-                    uint deltaG = TiffUtils.ConvertToUIntBigEndian(rowSpan);
+                    uint deltaG = TiffUtilities.ConvertToUIntBigEndian(rowSpan);
                     g += deltaG;
                     BinaryPrimitives.WriteUInt32BigEndian(rowSpan, g);
                     offset += 4;
 
                     rowSpan = rowBytes.Slice(offset, 4);
-                    uint deltaB = TiffUtils.ConvertToUIntBigEndian(rowSpan);
+                    uint deltaB = TiffUtilities.ConvertToUIntBigEndian(rowSpan);
                     b += deltaB;
                     BinaryPrimitives.WriteUInt32BigEndian(rowSpan, b);
                     offset += 4;
@@ -524,29 +520,29 @@ internal static class HorizontalPredictor
             {
                 int offset = 0;
                 Span<byte> rowBytes = pixelBytes.Slice(y * rowBytesCount, rowBytesCount);
-                uint r = TiffUtils.ConvertToUIntLittleEndian(rowBytes.Slice(offset, 4));
+                uint r = TiffUtilities.ConvertToUIntLittleEndian(rowBytes.Slice(offset, 4));
                 offset += 4;
-                uint g = TiffUtils.ConvertToUIntLittleEndian(rowBytes.Slice(offset, 4));
+                uint g = TiffUtilities.ConvertToUIntLittleEndian(rowBytes.Slice(offset, 4));
                 offset += 4;
-                uint b = TiffUtils.ConvertToUIntLittleEndian(rowBytes.Slice(offset, 4));
+                uint b = TiffUtilities.ConvertToUIntLittleEndian(rowBytes.Slice(offset, 4));
                 offset += 4;
 
                 for (int x = 1; x < width; x++)
                 {
                     Span<byte> rowSpan = rowBytes.Slice(offset, 4);
-                    uint deltaR = TiffUtils.ConvertToUIntLittleEndian(rowSpan);
+                    uint deltaR = TiffUtilities.ConvertToUIntLittleEndian(rowSpan);
                     r += deltaR;
                     BinaryPrimitives.WriteUInt32LittleEndian(rowSpan, r);
                     offset += 4;
 
                     rowSpan = rowBytes.Slice(offset, 4);
-                    uint deltaG = TiffUtils.ConvertToUIntLittleEndian(rowSpan);
+                    uint deltaG = TiffUtilities.ConvertToUIntLittleEndian(rowSpan);
                     g += deltaG;
                     BinaryPrimitives.WriteUInt32LittleEndian(rowSpan, g);
                     offset += 4;
 
                     rowSpan = rowBytes.Slice(offset, 4);
-                    uint deltaB = TiffUtils.ConvertToUIntLittleEndian(rowSpan);
+                    uint deltaB = TiffUtilities.ConvertToUIntLittleEndian(rowSpan);
                     b += deltaB;
                     BinaryPrimitives.WriteUInt32LittleEndian(rowSpan, b);
                     offset += 4;
@@ -565,37 +561,37 @@ internal static class HorizontalPredictor
             {
                 int offset = 0;
                 Span<byte> rowBytes = pixelBytes.Slice(y * rowBytesCount, rowBytesCount);
-                uint r = TiffUtils.ConvertToUIntBigEndian(rowBytes.Slice(offset, 4));
+                uint r = TiffUtilities.ConvertToUIntBigEndian(rowBytes.Slice(offset, 4));
                 offset += 4;
-                uint g = TiffUtils.ConvertToUIntBigEndian(rowBytes.Slice(offset, 4));
+                uint g = TiffUtilities.ConvertToUIntBigEndian(rowBytes.Slice(offset, 4));
                 offset += 4;
-                uint b = TiffUtils.ConvertToUIntBigEndian(rowBytes.Slice(offset, 4));
+                uint b = TiffUtilities.ConvertToUIntBigEndian(rowBytes.Slice(offset, 4));
                 offset += 4;
-                uint a = TiffUtils.ConvertToUIntBigEndian(rowBytes.Slice(offset, 4));
+                uint a = TiffUtilities.ConvertToUIntBigEndian(rowBytes.Slice(offset, 4));
                 offset += 4;
 
                 for (int x = 1; x < width; x++)
                 {
                     Span<byte> rowSpan = rowBytes.Slice(offset, 4);
-                    uint deltaR = TiffUtils.ConvertToUIntBigEndian(rowSpan);
+                    uint deltaR = TiffUtilities.ConvertToUIntBigEndian(rowSpan);
                     r += deltaR;
                     BinaryPrimitives.WriteUInt32BigEndian(rowSpan, r);
                     offset += 4;
 
                     rowSpan = rowBytes.Slice(offset, 4);
-                    uint deltaG = TiffUtils.ConvertToUIntBigEndian(rowSpan);
+                    uint deltaG = TiffUtilities.ConvertToUIntBigEndian(rowSpan);
                     g += deltaG;
                     BinaryPrimitives.WriteUInt32BigEndian(rowSpan, g);
                     offset += 4;
 
                     rowSpan = rowBytes.Slice(offset, 4);
-                    uint deltaB = TiffUtils.ConvertToUIntBigEndian(rowSpan);
+                    uint deltaB = TiffUtilities.ConvertToUIntBigEndian(rowSpan);
                     b += deltaB;
                     BinaryPrimitives.WriteUInt32BigEndian(rowSpan, b);
                     offset += 4;
 
                     rowSpan = rowBytes.Slice(offset, 4);
-                    uint deltaA = TiffUtils.ConvertToUIntBigEndian(rowSpan);
+                    uint deltaA = TiffUtilities.ConvertToUIntBigEndian(rowSpan);
                     a += deltaA;
                     BinaryPrimitives.WriteUInt32BigEndian(rowSpan, a);
                     offset += 4;
@@ -608,37 +604,37 @@ internal static class HorizontalPredictor
             {
                 int offset = 0;
                 Span<byte> rowBytes = pixelBytes.Slice(y * rowBytesCount, rowBytesCount);
-                uint r = TiffUtils.ConvertToUIntLittleEndian(rowBytes.Slice(offset, 4));
+                uint r = TiffUtilities.ConvertToUIntLittleEndian(rowBytes.Slice(offset, 4));
                 offset += 4;
-                uint g = TiffUtils.ConvertToUIntLittleEndian(rowBytes.Slice(offset, 4));
+                uint g = TiffUtilities.ConvertToUIntLittleEndian(rowBytes.Slice(offset, 4));
                 offset += 4;
-                uint b = TiffUtils.ConvertToUIntLittleEndian(rowBytes.Slice(offset, 4));
+                uint b = TiffUtilities.ConvertToUIntLittleEndian(rowBytes.Slice(offset, 4));
                 offset += 4;
-                uint a = TiffUtils.ConvertToUIntLittleEndian(rowBytes.Slice(offset, 4));
+                uint a = TiffUtilities.ConvertToUIntLittleEndian(rowBytes.Slice(offset, 4));
                 offset += 4;
 
                 for (int x = 1; x < width; x++)
                 {
                     Span<byte> rowSpan = rowBytes.Slice(offset, 4);
-                    uint deltaR = TiffUtils.ConvertToUIntLittleEndian(rowSpan);
+                    uint deltaR = TiffUtilities.ConvertToUIntLittleEndian(rowSpan);
                     r += deltaR;
                     BinaryPrimitives.WriteUInt32LittleEndian(rowSpan, r);
                     offset += 4;
 
                     rowSpan = rowBytes.Slice(offset, 4);
-                    uint deltaG = TiffUtils.ConvertToUIntLittleEndian(rowSpan);
+                    uint deltaG = TiffUtilities.ConvertToUIntLittleEndian(rowSpan);
                     g += deltaG;
                     BinaryPrimitives.WriteUInt32LittleEndian(rowSpan, g);
                     offset += 4;
 
                     rowSpan = rowBytes.Slice(offset, 4);
-                    uint deltaB = TiffUtils.ConvertToUIntLittleEndian(rowSpan);
+                    uint deltaB = TiffUtilities.ConvertToUIntLittleEndian(rowSpan);
                     b += deltaB;
                     BinaryPrimitives.WriteUInt32LittleEndian(rowSpan, b);
                     offset += 4;
 
                     rowSpan = rowBytes.Slice(offset, 4);
-                    uint deltaA = TiffUtils.ConvertToUIntLittleEndian(rowSpan);
+                    uint deltaA = TiffUtilities.ConvertToUIntLittleEndian(rowSpan);
                     a += deltaA;
                     BinaryPrimitives.WriteUInt32LittleEndian(rowSpan, a);
                     offset += 4;
diff --git a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/BlackIsZero16TiffColor{TPixel}.cs b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/BlackIsZero16TiffColor{TPixel}.cs
index 8763f9957..2ef261811 100644
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/BlackIsZero16TiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/BlackIsZero16TiffColor{TPixel}.cs
@@ -11,6 +11,7 @@ namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation;
 /// <summary>
 /// Implements the 'BlackIsZero' photometric interpretation for 16-bit grayscale images.
 /// </summary>
+/// <typeparam name="TPixel">The type of pixel format.</typeparam>
 internal class BlackIsZero16TiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
     where TPixel : unmanaged, IPixel<TPixel>
 {
@@ -32,9 +33,8 @@ internal class BlackIsZero16TiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
     /// <inheritdoc/>
     public override void Decode(ReadOnlySpan<byte> data, Buffer2D<TPixel> pixels, int left, int top, int width, int height)
     {
-        L16 l16 = TiffUtils.L16Default;
-        var color = default(TPixel);
-        color.FromScaledVector4(Vector4.Zero);
+        L16 l16 = TiffUtilities.L16Default;
+        TPixel color = TPixel.FromScaledVector4(Vector4.Zero);
 
         int offset = 0;
         for (int y = top; y < top + height; y++)
@@ -44,10 +44,10 @@ internal class BlackIsZero16TiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
             {
                 for (int x = 0; x < pixelRow.Length; x++)
                 {
-                    ushort intensity = TiffUtils.ConvertToUShortBigEndian(data.Slice(offset, 2));
+                    ushort intensity = TiffUtilities.ConvertToUShortBigEndian(data.Slice(offset, 2));
                     offset += 2;
 
-                    pixelRow[x] = TiffUtils.ColorFromL16(l16, intensity, color);
+                    pixelRow[x] = TPixel.FromL16(new(intensity));
                 }
             }
             else
diff --git a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/BlackIsZero1TiffColor{TPixel}.cs b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/BlackIsZero1TiffColor{TPixel}.cs
index a8a70f727..c9c0ee581 100644
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/BlackIsZero1TiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/BlackIsZero1TiffColor{TPixel}.cs
@@ -19,11 +19,9 @@ internal class BlackIsZero1TiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
     public override void Decode(ReadOnlySpan<byte> data, Buffer2D<TPixel> pixels, int left, int top, int width, int height)
     {
         nuint offset = 0;
-        TPixel colorBlack = default;
-        TPixel colorWhite = default;
+        TPixel colorBlack = TPixel.FromRgba32(Color.Black.ToPixel<Rgba32>());
+        TPixel colorWhite = TPixel.FromRgba32(Color.White.ToPixel<Rgba32>());
 
-        colorBlack.FromRgba32(Color.Black);
-        colorWhite.FromRgba32(Color.White);
         ref byte dataRef = ref MemoryMarshal.GetReference(data);
         for (nuint y = (uint)top; y < (uint)(top + height); y++)
         {
diff --git a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/BlackIsZero24TiffColor{TPixel}.cs b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/BlackIsZero24TiffColor{TPixel}.cs
index d57130a5f..07bf3d1bd 100644
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/BlackIsZero24TiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/BlackIsZero24TiffColor{TPixel}.cs
@@ -1,7 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System.Numerics;
 using SixLabors.ImageSharp.Formats.Tiff.Utils;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
@@ -11,6 +10,7 @@ namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation;
 /// <summary>
 /// Implements the 'BlackIsZero' photometric interpretation for 24-bit grayscale images.
 /// </summary>
+/// <typeparam name="TPixel">The type of pixel format.</typeparam>
 internal class BlackIsZero24TiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
     where TPixel : unmanaged, IPixel<TPixel>
 {
@@ -25,8 +25,6 @@ internal class BlackIsZero24TiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
     /// <inheritdoc/>
     public override void Decode(ReadOnlySpan<byte> data, Buffer2D<TPixel> pixels, int left, int top, int width, int height)
     {
-        var color = default(TPixel);
-        color.FromScaledVector4(Vector4.Zero);
         Span<byte> buffer = stackalloc byte[4];
         int bufferStartIdx = this.isBigEndian ? 1 : 0;
 
@@ -40,10 +38,10 @@ internal class BlackIsZero24TiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
                 for (int x = 0; x < pixelRow.Length; x++)
                 {
                     data.Slice(offset, 3).CopyTo(bufferSpan);
-                    ulong intensity = TiffUtils.ConvertToUIntBigEndian(buffer);
+                    uint intensity = TiffUtilities.ConvertToUIntBigEndian(buffer);
                     offset += 3;
 
-                    pixelRow[x] = TiffUtils.ColorScaleTo24Bit(intensity, color);
+                    pixelRow[x] = TiffUtilities.ColorScaleTo24Bit<TPixel>(intensity);
                 }
             }
             else
@@ -51,10 +49,10 @@ internal class BlackIsZero24TiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
                 for (int x = 0; x < pixelRow.Length; x++)
                 {
                     data.Slice(offset, 3).CopyTo(bufferSpan);
-                    ulong intensity = TiffUtils.ConvertToUIntLittleEndian(buffer);
+                    uint intensity = TiffUtilities.ConvertToUIntLittleEndian(buffer);
                     offset += 3;
 
-                    pixelRow[x] = TiffUtils.ColorScaleTo24Bit(intensity, color);
+                    pixelRow[x] = TiffUtilities.ColorScaleTo24Bit<TPixel>(intensity);
                 }
             }
         }
diff --git a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/BlackIsZero32FloatTiffColor{TPixel}.cs b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/BlackIsZero32FloatTiffColor{TPixel}.cs
index df37327c3..ac316459d 100644
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/BlackIsZero32FloatTiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/BlackIsZero32FloatTiffColor{TPixel}.cs
@@ -10,6 +10,7 @@ namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation;
 /// <summary>
 /// Implements the 'BlackIsZero' photometric interpretation for 32-bit float grayscale images.
 /// </summary>
+/// <typeparam name="TPixel">The type of pixel format.</typeparam>
 internal class BlackIsZero32FloatTiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
     where TPixel : unmanaged, IPixel<TPixel>
 {
@@ -24,8 +25,6 @@ internal class BlackIsZero32FloatTiffColor<TPixel> : TiffBaseColorDecoder<TPixel
     /// <inheritdoc/>
     public override void Decode(ReadOnlySpan<byte> data, Buffer2D<TPixel> pixels, int left, int top, int width, int height)
     {
-        TPixel color = default;
-        color.FromScaledVector4(Vector4.Zero);
         Span<byte> buffer = stackalloc byte[4];
 
         int offset = 0;
@@ -41,9 +40,7 @@ internal class BlackIsZero32FloatTiffColor<TPixel> : TiffBaseColorDecoder<TPixel
                     float intensity = BitConverter.ToSingle(buffer);
                     offset += 4;
 
-                    var colorVector = new Vector4(intensity, intensity, intensity, 1.0f);
-                    color.FromScaledVector4(colorVector);
-                    pixelRow[x] = color;
+                    pixelRow[x] = TPixel.FromScaledVector4(new Vector4(intensity, intensity, intensity, 1f));
                 }
             }
             else
@@ -53,9 +50,7 @@ internal class BlackIsZero32FloatTiffColor<TPixel> : TiffBaseColorDecoder<TPixel
                     float intensity = BitConverter.ToSingle(data.Slice(offset, 4));
                     offset += 4;
 
-                    var colorVector = new Vector4(intensity, intensity, intensity, 1.0f);
-                    color.FromScaledVector4(colorVector);
-                    pixelRow[x] = color;
+                    pixelRow[x] = TPixel.FromScaledVector4(new Vector4(intensity, intensity, intensity, 1f));
                 }
             }
         }
diff --git a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/BlackIsZero32TiffColor{TPixel}.cs b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/BlackIsZero32TiffColor{TPixel}.cs
index b5b3d8ee9..d51a5af65 100644
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/BlackIsZero32TiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/BlackIsZero32TiffColor{TPixel}.cs
@@ -1,7 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System.Numerics;
 using SixLabors.ImageSharp.Formats.Tiff.Utils;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
@@ -11,6 +10,7 @@ namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation;
 /// <summary>
 /// Implements the 'BlackIsZero' photometric interpretation for 32-bit grayscale images.
 /// </summary>
+/// <typeparam name="TPixel">The type of pixel format.</typeparam>
 internal class BlackIsZero32TiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
     where TPixel : unmanaged, IPixel<TPixel>
 {
@@ -25,9 +25,6 @@ internal class BlackIsZero32TiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
     /// <inheritdoc/>
     public override void Decode(ReadOnlySpan<byte> data, Buffer2D<TPixel> pixels, int left, int top, int width, int height)
     {
-        var color = default(TPixel);
-        color.FromScaledVector4(Vector4.Zero);
-
         int offset = 0;
         for (int y = top; y < top + height; y++)
         {
@@ -36,20 +33,20 @@ internal class BlackIsZero32TiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
             {
                 for (int x = 0; x < pixelRow.Length; x++)
                 {
-                    ulong intensity = TiffUtils.ConvertToUIntBigEndian(data.Slice(offset, 4));
+                    uint intensity = TiffUtilities.ConvertToUIntBigEndian(data.Slice(offset, 4));
                     offset += 4;
 
-                    pixelRow[x] = TiffUtils.ColorScaleTo32Bit(intensity, color);
+                    pixelRow[x] = TiffUtilities.ColorScaleTo32Bit<TPixel>(intensity);
                 }
             }
             else
             {
                 for (int x = 0; x < pixelRow.Length; x++)
                 {
-                    ulong intensity = TiffUtils.ConvertToUIntLittleEndian(data.Slice(offset, 4));
+                    uint intensity = TiffUtilities.ConvertToUIntLittleEndian(data.Slice(offset, 4));
                     offset += 4;
 
-                    pixelRow[x] = TiffUtils.ColorScaleTo32Bit(intensity, color);
+                    pixelRow[x] = TiffUtilities.ColorScaleTo32Bit<TPixel>(intensity);
                 }
             }
         }
diff --git a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/BlackIsZero4TiffColor{TPixel}.cs b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/BlackIsZero4TiffColor{TPixel}.cs
index 16b995441..1d33f1a24 100644
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/BlackIsZero4TiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/BlackIsZero4TiffColor{TPixel}.cs
@@ -9,47 +9,30 @@ namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation;
 /// <summary>
 /// Implements the 'BlackIsZero' photometric interpretation (optimized for 4-bit grayscale images).
 /// </summary>
+/// <typeparam name="TPixel">The type of pixel format.</typeparam>
 internal class BlackIsZero4TiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
     where TPixel : unmanaged, IPixel<TPixel>
 {
     /// <inheritdoc/>
     public override void Decode(ReadOnlySpan<byte> data, Buffer2D<TPixel> pixels, int left, int top, int width, int height)
     {
-        var color = default(TPixel);
-
         int offset = 0;
         bool isOddWidth = (width & 1) == 1;
 
-        var l8 = default(L8);
         for (int y = top; y < top + height; y++)
         {
             Span<TPixel> pixelRowSpan = pixels.DangerousGetRowSpan(y);
             for (int x = left; x < left + width - 1;)
             {
                 byte byteData = data[offset++];
-
-                byte intensity1 = (byte)(((byteData & 0xF0) >> 4) * 17);
-                l8.PackedValue = intensity1;
-                color.FromL8(l8);
-
-                pixelRowSpan[x++] = color;
-
-                byte intensity2 = (byte)((byteData & 0x0F) * 17);
-                l8.PackedValue = intensity2;
-                color.FromL8(l8);
-
-                pixelRowSpan[x++] = color;
+                pixelRowSpan[x++] = TPixel.FromL8(new((byte)(((byteData & 0xF0) >> 4) * 17)));
+                pixelRowSpan[x++] = TPixel.FromL8(new((byte)((byteData & 0x0F) * 17)));
             }
 
             if (isOddWidth)
             {
                 byte byteData = data[offset++];
-
-                byte intensity1 = (byte)(((byteData & 0xF0) >> 4) * 17);
-                l8.PackedValue = intensity1;
-                color.FromL8(l8);
-
-                pixelRowSpan[left + width - 1] = color;
+                pixelRowSpan[left + width - 1] = TPixel.FromL8(new((byte)(((byteData & 0xF0) >> 4) * 17)));
             }
         }
     }
diff --git a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/BlackIsZeroTiffColor{TPixel}.cs b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/BlackIsZeroTiffColor{TPixel}.cs
index b086cb43e..709c2bf64 100644
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/BlackIsZeroTiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/BlackIsZeroTiffColor{TPixel}.cs
@@ -1,7 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System.Numerics;
 using SixLabors.ImageSharp.Formats.Tiff.Utils;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
@@ -11,25 +10,23 @@ namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation;
 /// <summary>
 /// Implements the 'BlackIsZero' photometric interpretation (for all bit depths).
 /// </summary>
+/// <typeparam name="TPixel">The type of pixel format.</typeparam>
 internal class BlackIsZeroTiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
     where TPixel : unmanaged, IPixel<TPixel>
 {
     private readonly ushort bitsPerSample0;
-
     private readonly float factor;
 
     public BlackIsZeroTiffColor(TiffBitsPerSample bitsPerSample)
     {
         this.bitsPerSample0 = bitsPerSample.Channel0;
-        this.factor = (1 << this.bitsPerSample0) - 1.0f;
+        this.factor = (1 << this.bitsPerSample0) - 1f;
     }
 
     /// <inheritdoc/>
     public override void Decode(ReadOnlySpan<byte> data, Buffer2D<TPixel> pixels, int left, int top, int width, int height)
     {
-        var color = default(TPixel);
-
-        var bitReader = new BitReader(data);
+        BitReader bitReader = new(data);
 
         for (int y = top; y < top + height; y++)
         {
@@ -38,9 +35,7 @@ internal class BlackIsZeroTiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
             {
                 int value = bitReader.ReadBits(this.bitsPerSample0);
                 float intensity = value / this.factor;
-
-                color.FromScaledVector4(new Vector4(intensity, intensity, intensity, 1.0f));
-                pixelRow[x] = color;
+                pixelRow[x] = TPixel.FromScaledVector4(new(intensity, intensity, intensity, 1f));
             }
 
             bitReader.NextRow();
diff --git a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/CieLabPlanarTiffColor{TPixel}.cs b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/CieLabPlanarTiffColor{TPixel}.cs
index 216d17330..6be584581 100644
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/CieLabPlanarTiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/CieLabPlanarTiffColor{TPixel}.cs
@@ -2,7 +2,6 @@
 // Licensed under the Six Labors Split License.
 
 using System.Buffers;
-using System.Numerics;
 using SixLabors.ImageSharp.ColorSpaces;
 using SixLabors.ImageSharp.ColorSpaces.Conversion;
 using SixLabors.ImageSharp.Memory;
@@ -13,6 +12,7 @@ namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation;
 /// <summary>
 /// Implements decoding pixel data with photometric interpretation of type 'CieLab' with the planar configuration.
 /// </summary>
+/// <typeparam name="TPixel">The type of pixel format.</typeparam>
 internal class CieLabPlanarTiffColor<TPixel> : TiffBasePlanarColorDecoder<TPixel>
     where TPixel : unmanaged, IPixel<TPixel>
 {
@@ -23,22 +23,19 @@ internal class CieLabPlanarTiffColor<TPixel> : TiffBasePlanarColorDecoder<TPixel
     /// <inheritdoc/>
     public override void Decode(IMemoryOwner<byte>[] data, Buffer2D<TPixel> pixels, int left, int top, int width, int height)
     {
-        Span<byte> l = data[0].GetSpan();
-        Span<byte> a = data[1].GetSpan();
         Span<byte> b = data[2].GetSpan();
+        Span<byte> a = data[1].GetSpan();
+        Span<byte> l = data[0].GetSpan();
 
-        var color = default(TPixel);
         int offset = 0;
         for (int y = top; y < top + height; y++)
         {
             Span<TPixel> pixelRow = pixels.DangerousGetRowSpan(y).Slice(left, width);
             for (int x = 0; x < pixelRow.Length; x++)
             {
-                var lab = new CieLab((l[offset] & 0xFF) * 100f * Inv255, (sbyte)a[offset], (sbyte)b[offset]);
-                var rgb = ColorSpaceConverter.ToRgb(lab);
-
-                color.FromVector4(new Vector4(rgb.R, rgb.G, rgb.B, 1.0f));
-                pixelRow[x] = color;
+                CieLab lab = new((l[offset] & 0xFF) * 100f * Inv255, (sbyte)a[offset], (sbyte)b[offset]);
+                Rgb rgb = ColorSpaceConverter.ToRgb(lab);
+                pixelRow[x] = TPixel.FromScaledVector4(new(rgb.R, rgb.G, rgb.B, 1.0f));
 
                 offset++;
             }
diff --git a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/CieLabTiffColor{TPixel}.cs b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/CieLabTiffColor{TPixel}.cs
index b39a64644..e5dc574f7 100644
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/CieLabTiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/CieLabTiffColor{TPixel}.cs
@@ -1,7 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System.Numerics;
 using SixLabors.ImageSharp.ColorSpaces;
 using SixLabors.ImageSharp.ColorSpaces.Conversion;
 using SixLabors.ImageSharp.Memory;
@@ -12,17 +11,16 @@ namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation;
 /// <summary>
 /// Implements decoding pixel data with photometric interpretation of type 'CieLab'.
 /// </summary>
+/// <typeparam name="TPixel">The type of pixel format.</typeparam>
 internal class CieLabTiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
     where TPixel : unmanaged, IPixel<TPixel>
 {
     private static readonly ColorSpaceConverter ColorSpaceConverter = new();
-
-    private const float Inv255 = 1.0f / 255.0f;
+    private const float Inv255 = 1f / 255f;
 
     /// <inheritdoc/>
     public override void Decode(ReadOnlySpan<byte> data, Buffer2D<TPixel> pixels, int left, int top, int width, int height)
     {
-        TPixel color = default;
         int offset = 0;
         for (int y = top; y < top + height; y++)
         {
@@ -33,9 +31,7 @@ internal class CieLabTiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
                 float l = (data[offset] & 0xFF) * 100f * Inv255;
                 CieLab lab = new(l, (sbyte)data[offset + 1], (sbyte)data[offset + 2]);
                 Rgb rgb = ColorSpaceConverter.ToRgb(lab);
-
-                color.FromVector4(new Vector4(rgb.R, rgb.G, rgb.B, 1.0f));
-                pixelRow[x] = color;
+                pixelRow[x] = TPixel.FromScaledVector4(new(rgb.R, rgb.G, rgb.B, 1f));
 
                 offset += 3;
             }
diff --git a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/CmykTiffColor{TPixel}.cs b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/CmykTiffColor{TPixel}.cs
index c87051d52..77baa5351 100644
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/CmykTiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/CmykTiffColor{TPixel}.cs
@@ -1,7 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System.Numerics;
 using SixLabors.ImageSharp.ColorSpaces;
 using SixLabors.ImageSharp.ColorSpaces.Conversion;
 using SixLabors.ImageSharp.Memory;
@@ -12,12 +11,11 @@ namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation;
 internal class CmykTiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
     where TPixel : unmanaged, IPixel<TPixel>
 {
-    private const float Inv255 = 1 / 255.0f;
+    private const float Inv255 = 1f / 255f;
 
     /// <inheritdoc/>
     public override void Decode(ReadOnlySpan<byte> data, Buffer2D<TPixel> pixels, int left, int top, int width, int height)
     {
-        TPixel color = default;
         int offset = 0;
         for (int y = top; y < top + height; y++)
         {
@@ -26,9 +24,7 @@ internal class CmykTiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
             {
                 Cmyk cmyk = new(data[offset] * Inv255, data[offset + 1] * Inv255, data[offset + 2] * Inv255, data[offset + 3] * Inv255);
                 Rgb rgb = ColorSpaceConverter.ToRgb(in cmyk);
-
-                color.FromVector4(new Vector4(rgb.R, rgb.G, rgb.B, 1.0f));
-                pixelRow[x] = color;
+                pixelRow[x] = TPixel.FromScaledVector4(new(rgb.R, rgb.G, rgb.B, 1.0f));
 
                 offset += 4;
             }
diff --git a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/PaletteTiffColor{TPixel}.cs b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/PaletteTiffColor{TPixel}.cs
index 22db1918c..745e5846a 100644
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/PaletteTiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/PaletteTiffColor{TPixel}.cs
@@ -1,7 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System.Numerics;
 using SixLabors.ImageSharp.Formats.Tiff.Utils;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
@@ -11,6 +10,7 @@ namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation;
 /// <summary>
 /// Implements the 'PaletteTiffColor' photometric interpretation (for all bit depths).
 /// </summary>
+/// <typeparam name="TPixel">The type of pixel format.</typeparam>
 internal class PaletteTiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
     where TPixel : unmanaged, IPixel<TPixel>
 {
@@ -18,8 +18,11 @@ internal class PaletteTiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
 
     private readonly TPixel[] palette;
 
-    private const float InvMax = 1.0f / 65535F;
+    private const float InvMax = 1f / 65535f;
 
+    /// <summary>
+    /// Initializes a new instance of the <see cref="PaletteTiffColor{TPixel}"/> class.
+    /// </summary>
     /// <param name="bitsPerSample">The number of bits per sample for each pixel.</param>
     /// <param name="colorMap">The RGB color lookup table to use for decoding the image.</param>
     public PaletteTiffColor(TiffBitsPerSample bitsPerSample, ushort[] colorMap)
@@ -32,7 +35,7 @@ internal class PaletteTiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
     /// <inheritdoc/>
     public override void Decode(ReadOnlySpan<byte> data, Buffer2D<TPixel> pixels, int left, int top, int width, int height)
     {
-        var bitReader = new BitReader(data);
+        BitReader bitReader = new(data);
 
         for (int y = top; y < top + height; y++)
         {
@@ -49,7 +52,7 @@ internal class PaletteTiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
 
     private static TPixel[] GeneratePalette(ushort[] colorMap, int colorCount)
     {
-        var palette = new TPixel[colorCount];
+        TPixel[] palette = new TPixel[colorCount];
 
         const int rOffset = 0;
         int gOffset = colorCount;
@@ -60,7 +63,7 @@ internal class PaletteTiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
             float r = colorMap[rOffset + i] * InvMax;
             float g = colorMap[gOffset + i] * InvMax;
             float b = colorMap[bOffset + i] * InvMax;
-            palette[i].FromScaledVector4(new Vector4(r, g, b, 1.0f));
+            palette[i] = TPixel.FromScaledVector4(new(r, g, b, 1f));
         }
 
         return palette;
diff --git a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgb161616TiffColor{TPixel}.cs b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgb161616TiffColor{TPixel}.cs
index 8ca45c939..d8520e307 100644
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgb161616TiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgb161616TiffColor{TPixel}.cs
@@ -1,7 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System.Numerics;
 using SixLabors.ImageSharp.Formats.Tiff.Utils;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
@@ -11,11 +10,11 @@ namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation;
 /// <summary>
 /// Implements the 'RGB' photometric interpretation with 16 bits for each channel.
 /// </summary>
+/// <typeparam name="TPixel">The type of pixel format.</typeparam>
 internal class Rgb161616TiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
     where TPixel : unmanaged, IPixel<TPixel>
 {
     private readonly bool isBigEndian;
-
     private readonly Configuration configuration;
 
     /// <summary>
@@ -32,10 +31,6 @@ internal class Rgb161616TiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
     /// <inheritdoc/>
     public override void Decode(ReadOnlySpan<byte> data, Buffer2D<TPixel> pixels, int left, int top, int width, int height)
     {
-        Rgba64 rgba = TiffUtils.Rgba64Default;
-        var color = default(TPixel);
-        color.FromScaledVector4(Vector4.Zero);
-
         int offset = 0;
 
         for (int y = top; y < top + height; y++)
@@ -46,14 +41,14 @@ internal class Rgb161616TiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
             {
                 for (int x = 0; x < pixelRow.Length; x++)
                 {
-                    ulong r = TiffUtils.ConvertToUShortBigEndian(data.Slice(offset, 2));
+                    ushort r = TiffUtilities.ConvertToUShortBigEndian(data.Slice(offset, 2));
                     offset += 2;
-                    ulong g = TiffUtils.ConvertToUShortBigEndian(data.Slice(offset, 2));
+                    ushort g = TiffUtilities.ConvertToUShortBigEndian(data.Slice(offset, 2));
                     offset += 2;
-                    ulong b = TiffUtils.ConvertToUShortBigEndian(data.Slice(offset, 2));
+                    ushort b = TiffUtilities.ConvertToUShortBigEndian(data.Slice(offset, 2));
                     offset += 2;
 
-                    pixelRow[x] = TiffUtils.ColorFromRgb64(rgba, r, g, b, color);
+                    pixelRow[x] = TPixel.FromRgb48(new(r, g, b));
                 }
             }
             else
diff --git a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgb16PlanarTiffColor{TPixel}.cs b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgb16PlanarTiffColor{TPixel}.cs
index 08fb6d8be..f55d7225e 100644
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgb16PlanarTiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgb16PlanarTiffColor{TPixel}.cs
@@ -2,7 +2,6 @@
 // Licensed under the Six Labors Split License.
 
 using System.Buffers;
-using System.Numerics;
 using SixLabors.ImageSharp.Formats.Tiff.Utils;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
@@ -12,6 +11,7 @@ namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation;
 /// <summary>
 /// Implements the 'RGB' photometric interpretation with 'Planar' layout for each color channel with 16 bit.
 /// </summary>
+/// <typeparam name="TPixel">The type of pixel format.</typeparam>
 internal class Rgb16PlanarTiffColor<TPixel> : TiffBasePlanarColorDecoder<TPixel>
     where TPixel : unmanaged, IPixel<TPixel>
 {
@@ -26,10 +26,6 @@ internal class Rgb16PlanarTiffColor<TPixel> : TiffBasePlanarColorDecoder<TPixel>
     /// <inheritdoc/>
     public override void Decode(IMemoryOwner<byte>[] data, Buffer2D<TPixel> pixels, int left, int top, int width, int height)
     {
-        Rgba64 rgba = TiffUtils.Rgba64Default;
-        var color = default(TPixel);
-        color.FromScaledVector4(Vector4.Zero);
-
         Span<byte> redData = data[0].GetSpan();
         Span<byte> greenData = data[1].GetSpan();
         Span<byte> blueData = data[2].GetSpan();
@@ -42,26 +38,26 @@ internal class Rgb16PlanarTiffColor<TPixel> : TiffBasePlanarColorDecoder<TPixel>
             {
                 for (int x = 0; x < pixelRow.Length; x++)
                 {
-                    ulong r = TiffUtils.ConvertToUShortBigEndian(redData.Slice(offset, 2));
-                    ulong g = TiffUtils.ConvertToUShortBigEndian(greenData.Slice(offset, 2));
-                    ulong b = TiffUtils.ConvertToUShortBigEndian(blueData.Slice(offset, 2));
+                    ushort r = TiffUtilities.ConvertToUShortBigEndian(redData.Slice(offset, 2));
+                    ushort g = TiffUtilities.ConvertToUShortBigEndian(greenData.Slice(offset, 2));
+                    ushort b = TiffUtilities.ConvertToUShortBigEndian(blueData.Slice(offset, 2));
 
                     offset += 2;
 
-                    pixelRow[x] = TiffUtils.ColorFromRgb64(rgba, r, g, b, color);
+                    pixelRow[x] = TPixel.FromRgb48(new(r, g, b));
                 }
             }
             else
             {
                 for (int x = 0; x < pixelRow.Length; x++)
                 {
-                    ulong r = TiffUtils.ConvertToUShortLittleEndian(redData.Slice(offset, 2));
-                    ulong g = TiffUtils.ConvertToUShortLittleEndian(greenData.Slice(offset, 2));
-                    ulong b = TiffUtils.ConvertToUShortLittleEndian(blueData.Slice(offset, 2));
+                    ushort r = TiffUtilities.ConvertToUShortLittleEndian(redData.Slice(offset, 2));
+                    ushort g = TiffUtilities.ConvertToUShortLittleEndian(greenData.Slice(offset, 2));
+                    ushort b = TiffUtilities.ConvertToUShortLittleEndian(blueData.Slice(offset, 2));
 
                     offset += 2;
 
-                    pixelRow[x] = TiffUtils.ColorFromRgb64(rgba, r, g, b, color);
+                    pixelRow[x] = TPixel.FromRgb48(new(r, g, b));
                 }
             }
         }
diff --git a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgb242424TiffColor{TPixel}.cs b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgb242424TiffColor{TPixel}.cs
index 027dcce3b..074c08530 100644
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgb242424TiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgb242424TiffColor{TPixel}.cs
@@ -1,7 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System.Numerics;
 using SixLabors.ImageSharp.Formats.Tiff.Utils;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
@@ -11,6 +10,7 @@ namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation;
 /// <summary>
 /// Implements the 'RGB' photometric interpretation with 24 bits for each channel.
 /// </summary>
+/// <typeparam name="TPixel">The type of pixel format.</typeparam>
 internal class Rgb242424TiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
     where TPixel : unmanaged, IPixel<TPixel>
 {
@@ -25,8 +25,6 @@ internal class Rgb242424TiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
     /// <inheritdoc/>
     public override void Decode(ReadOnlySpan<byte> data, Buffer2D<TPixel> pixels, int left, int top, int width, int height)
     {
-        var color = default(TPixel);
-        color.FromScaledVector4(Vector4.Zero);
         int offset = 0;
         Span<byte> buffer = stackalloc byte[4];
         int bufferStartIdx = this.isBigEndian ? 1 : 0;
@@ -41,18 +39,18 @@ internal class Rgb242424TiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
                 for (int x = 0; x < pixelRow.Length; x++)
                 {
                     data.Slice(offset, 3).CopyTo(bufferSpan);
-                    ulong r = TiffUtils.ConvertToUIntBigEndian(buffer);
+                    uint r = TiffUtilities.ConvertToUIntBigEndian(buffer);
                     offset += 3;
 
                     data.Slice(offset, 3).CopyTo(bufferSpan);
-                    ulong g = TiffUtils.ConvertToUIntBigEndian(buffer);
+                    uint g = TiffUtilities.ConvertToUIntBigEndian(buffer);
                     offset += 3;
 
                     data.Slice(offset, 3).CopyTo(bufferSpan);
-                    ulong b = TiffUtils.ConvertToUIntBigEndian(buffer);
+                    uint b = TiffUtilities.ConvertToUIntBigEndian(buffer);
                     offset += 3;
 
-                    pixelRow[x] = TiffUtils.ColorScaleTo24Bit(r, g, b, color);
+                    pixelRow[x] = TiffUtilities.ColorScaleTo24Bit<TPixel>(r, g, b);
                 }
             }
             else
@@ -60,18 +58,18 @@ internal class Rgb242424TiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
                 for (int x = 0; x < pixelRow.Length; x++)
                 {
                     data.Slice(offset, 3).CopyTo(bufferSpan);
-                    ulong r = TiffUtils.ConvertToUIntLittleEndian(buffer);
+                    uint r = TiffUtilities.ConvertToUIntLittleEndian(buffer);
                     offset += 3;
 
                     data.Slice(offset, 3).CopyTo(bufferSpan);
-                    ulong g = TiffUtils.ConvertToUIntLittleEndian(buffer);
+                    uint g = TiffUtilities.ConvertToUIntLittleEndian(buffer);
                     offset += 3;
 
                     data.Slice(offset, 3).CopyTo(bufferSpan);
-                    ulong b = TiffUtils.ConvertToUIntLittleEndian(buffer);
+                    uint b = TiffUtilities.ConvertToUIntLittleEndian(buffer);
                     offset += 3;
 
-                    pixelRow[x] = TiffUtils.ColorScaleTo24Bit(r, g, b, color);
+                    pixelRow[x] = TiffUtilities.ColorScaleTo24Bit<TPixel>(r, g, b);
                 }
             }
         }
diff --git a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgb24PlanarTiffColor{TPixel}.cs b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgb24PlanarTiffColor{TPixel}.cs
index eba29a7f7..03ee94c27 100644
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgb24PlanarTiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgb24PlanarTiffColor{TPixel}.cs
@@ -2,7 +2,6 @@
 // Licensed under the Six Labors Split License.
 
 using System.Buffers;
-using System.Numerics;
 using SixLabors.ImageSharp.Formats.Tiff.Utils;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
@@ -12,6 +11,7 @@ namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation;
 /// <summary>
 /// Implements the 'RGB' photometric interpretation with 'Planar' layout for each color channel with 24 bit.
 /// </summary>
+/// <typeparam name="TPixel">The type of pixel format.</typeparam>
 internal class Rgb24PlanarTiffColor<TPixel> : TiffBasePlanarColorDecoder<TPixel>
     where TPixel : unmanaged, IPixel<TPixel>
 {
@@ -26,8 +26,6 @@ internal class Rgb24PlanarTiffColor<TPixel> : TiffBasePlanarColorDecoder<TPixel>
     /// <inheritdoc/>
     public override void Decode(IMemoryOwner<byte>[] data, Buffer2D<TPixel> pixels, int left, int top, int width, int height)
     {
-        var color = default(TPixel);
-        color.FromScaledVector4(Vector4.Zero);
         Span<byte> buffer = stackalloc byte[4];
         int bufferStartIdx = this.isBigEndian ? 1 : 0;
 
@@ -45,15 +43,15 @@ internal class Rgb24PlanarTiffColor<TPixel> : TiffBasePlanarColorDecoder<TPixel>
                 for (int x = 0; x < pixelRow.Length; x++)
                 {
                     redData.Slice(offset, 3).CopyTo(bufferSpan);
-                    ulong r = TiffUtils.ConvertToUIntBigEndian(buffer);
+                    uint r = TiffUtilities.ConvertToUIntBigEndian(buffer);
                     greenData.Slice(offset, 3).CopyTo(bufferSpan);
-                    ulong g = TiffUtils.ConvertToUIntBigEndian(buffer);
+                    uint g = TiffUtilities.ConvertToUIntBigEndian(buffer);
                     blueData.Slice(offset, 3).CopyTo(bufferSpan);
-                    ulong b = TiffUtils.ConvertToUIntBigEndian(buffer);
+                    uint b = TiffUtilities.ConvertToUIntBigEndian(buffer);
 
                     offset += 3;
 
-                    pixelRow[x] = TiffUtils.ColorScaleTo24Bit(r, g, b, color);
+                    pixelRow[x] = TiffUtilities.ColorScaleTo24Bit<TPixel>(r, g, b);
                 }
             }
             else
@@ -61,15 +59,15 @@ internal class Rgb24PlanarTiffColor<TPixel> : TiffBasePlanarColorDecoder<TPixel>
                 for (int x = 0; x < pixelRow.Length; x++)
                 {
                     redData.Slice(offset, 3).CopyTo(bufferSpan);
-                    ulong r = TiffUtils.ConvertToUIntLittleEndian(buffer);
+                    uint r = TiffUtilities.ConvertToUIntLittleEndian(buffer);
                     greenData.Slice(offset, 3).CopyTo(bufferSpan);
-                    ulong g = TiffUtils.ConvertToUIntLittleEndian(buffer);
+                    uint g = TiffUtilities.ConvertToUIntLittleEndian(buffer);
                     blueData.Slice(offset, 3).CopyTo(bufferSpan);
-                    ulong b = TiffUtils.ConvertToUIntLittleEndian(buffer);
+                    uint b = TiffUtilities.ConvertToUIntLittleEndian(buffer);
 
                     offset += 3;
 
-                    pixelRow[x] = TiffUtils.ColorScaleTo24Bit(r, g, b, color);
+                    pixelRow[x] = TiffUtilities.ColorScaleTo24Bit<TPixel>(r, g, b);
                 }
             }
         }
diff --git a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgb323232TiffColor{TPixel}.cs b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgb323232TiffColor{TPixel}.cs
index 79f66c143..5f0497259 100644
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgb323232TiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgb323232TiffColor{TPixel}.cs
@@ -1,7 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System.Numerics;
 using SixLabors.ImageSharp.Formats.Tiff.Utils;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
@@ -11,6 +10,7 @@ namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation;
 /// <summary>
 /// Implements the 'RGB' photometric interpretation with 32 bits for each channel.
 /// </summary>
+/// <typeparam name="TPixel">The type of pixel format.</typeparam>
 internal class Rgb323232TiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
     where TPixel : unmanaged, IPixel<TPixel>
 {
@@ -25,8 +25,6 @@ internal class Rgb323232TiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
     /// <inheritdoc/>
     public override void Decode(ReadOnlySpan<byte> data, Buffer2D<TPixel> pixels, int left, int top, int width, int height)
     {
-        var color = default(TPixel);
-        color.FromScaledVector4(Vector4.Zero);
         int offset = 0;
 
         for (int y = top; y < top + height; y++)
@@ -37,32 +35,32 @@ internal class Rgb323232TiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
             {
                 for (int x = 0; x < pixelRow.Length; x++)
                 {
-                    ulong r = TiffUtils.ConvertToUIntBigEndian(data.Slice(offset, 4));
+                    uint r = TiffUtilities.ConvertToUIntBigEndian(data.Slice(offset, 4));
                     offset += 4;
 
-                    ulong g = TiffUtils.ConvertToUIntBigEndian(data.Slice(offset, 4));
+                    uint g = TiffUtilities.ConvertToUIntBigEndian(data.Slice(offset, 4));
                     offset += 4;
 
-                    ulong b = TiffUtils.ConvertToUIntBigEndian(data.Slice(offset, 4));
+                    uint b = TiffUtilities.ConvertToUIntBigEndian(data.Slice(offset, 4));
                     offset += 4;
 
-                    pixelRow[x] = TiffUtils.ColorScaleTo32Bit(r, g, b, color);
+                    pixelRow[x] = TiffUtilities.ColorScaleTo32Bit<TPixel>(r, g, b);
                 }
             }
             else
             {
                 for (int x = 0; x < pixelRow.Length; x++)
                 {
-                    ulong r = TiffUtils.ConvertToUIntLittleEndian(data.Slice(offset, 4));
+                    uint r = TiffUtilities.ConvertToUIntLittleEndian(data.Slice(offset, 4));
                     offset += 4;
 
-                    ulong g = TiffUtils.ConvertToUIntLittleEndian(data.Slice(offset, 4));
+                    uint g = TiffUtilities.ConvertToUIntLittleEndian(data.Slice(offset, 4));
                     offset += 4;
 
-                    ulong b = TiffUtils.ConvertToUIntLittleEndian(data.Slice(offset, 4));
+                    uint b = TiffUtilities.ConvertToUIntLittleEndian(data.Slice(offset, 4));
                     offset += 4;
 
-                    pixelRow[x] = TiffUtils.ColorScaleTo32Bit(r, g, b, color);
+                    pixelRow[x] = TiffUtilities.ColorScaleTo32Bit<TPixel>(r, g, b);
                 }
             }
         }
diff --git a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgb32PlanarTiffColor{TPixel}.cs b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgb32PlanarTiffColor{TPixel}.cs
index 472697dd5..caa6eb51d 100644
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgb32PlanarTiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgb32PlanarTiffColor{TPixel}.cs
@@ -2,7 +2,6 @@
 // Licensed under the Six Labors Split License.
 
 using System.Buffers;
-using System.Numerics;
 using SixLabors.ImageSharp.Formats.Tiff.Utils;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
@@ -12,6 +11,7 @@ namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation;
 /// <summary>
 /// Implements the 'RGB' photometric interpretation with 'Planar' layout for each color channel with 32 bit.
 /// </summary>
+/// <typeparam name="TPixel">The type of pixel format.</typeparam>
 internal class Rgb32PlanarTiffColor<TPixel> : TiffBasePlanarColorDecoder<TPixel>
     where TPixel : unmanaged, IPixel<TPixel>
 {
@@ -26,9 +26,6 @@ internal class Rgb32PlanarTiffColor<TPixel> : TiffBasePlanarColorDecoder<TPixel>
     /// <inheritdoc/>
     public override void Decode(IMemoryOwner<byte>[] data, Buffer2D<TPixel> pixels, int left, int top, int width, int height)
     {
-        var color = default(TPixel);
-        color.FromScaledVector4(Vector4.Zero);
-
         Span<byte> redData = data[0].GetSpan();
         Span<byte> greenData = data[1].GetSpan();
         Span<byte> blueData = data[2].GetSpan();
@@ -41,26 +38,26 @@ internal class Rgb32PlanarTiffColor<TPixel> : TiffBasePlanarColorDecoder<TPixel>
             {
                 for (int x = 0; x < pixelRow.Length; x++)
                 {
-                    ulong r = TiffUtils.ConvertToUIntBigEndian(redData.Slice(offset, 4));
-                    ulong g = TiffUtils.ConvertToUIntBigEndian(greenData.Slice(offset, 4));
-                    ulong b = TiffUtils.ConvertToUIntBigEndian(blueData.Slice(offset, 4));
+                    uint r = TiffUtilities.ConvertToUIntBigEndian(redData.Slice(offset, 4));
+                    uint g = TiffUtilities.ConvertToUIntBigEndian(greenData.Slice(offset, 4));
+                    uint b = TiffUtilities.ConvertToUIntBigEndian(blueData.Slice(offset, 4));
 
                     offset += 4;
 
-                    pixelRow[x] = TiffUtils.ColorScaleTo32Bit(r, g, b, color);
+                    pixelRow[x] = TiffUtilities.ColorScaleTo32Bit<TPixel>(r, g, b);
                 }
             }
             else
             {
                 for (int x = 0; x < pixelRow.Length; x++)
                 {
-                    ulong r = TiffUtils.ConvertToUIntLittleEndian(redData.Slice(offset, 4));
-                    ulong g = TiffUtils.ConvertToUIntLittleEndian(greenData.Slice(offset, 4));
-                    ulong b = TiffUtils.ConvertToUIntLittleEndian(blueData.Slice(offset, 4));
+                    uint r = TiffUtilities.ConvertToUIntLittleEndian(redData.Slice(offset, 4));
+                    uint g = TiffUtilities.ConvertToUIntLittleEndian(greenData.Slice(offset, 4));
+                    uint b = TiffUtilities.ConvertToUIntLittleEndian(blueData.Slice(offset, 4));
 
                     offset += 4;
 
-                    pixelRow[x] = TiffUtils.ColorScaleTo32Bit(r, g, b, color);
+                    pixelRow[x] = TiffUtilities.ColorScaleTo32Bit<TPixel>(r, g, b);
                 }
             }
         }
diff --git a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgb444TiffColor{TPixel}.cs b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgb444TiffColor{TPixel}.cs
index 7c6a4a0ec..3a90e8174 100644
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgb444TiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgb444TiffColor{TPixel}.cs
@@ -9,17 +9,15 @@ namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation;
 /// <summary>
 /// Implements the 'RGB' photometric interpretation for 4 bits per color channel images.
 /// </summary>
+/// <typeparam name="TPixel">The type of pixel format.</typeparam>
 internal class Rgb444TiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
     where TPixel : unmanaged, IPixel<TPixel>
 {
     /// <inheritdoc/>
     public override void Decode(ReadOnlySpan<byte> data, Buffer2D<TPixel> pixels, int left, int top, int width, int height)
     {
-        var color = default(TPixel);
-
         int offset = 0;
 
-        var bgra = default(Bgra4444);
         for (int y = top; y < top + height; y++)
         {
             Span<TPixel> pixelRow = pixels.DangerousGetRowSpan(y);
@@ -31,9 +29,8 @@ internal class Rgb444TiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
                 offset++;
                 byte b = (byte)((data[offset] & 0xF0) >> 4);
 
-                bgra.PackedValue = ToBgraPackedValue(b, g, r);
-                color.FromScaledVector4(bgra.ToScaledVector4());
-                pixelRow[x] = color;
+                Bgra4444 bgra = new() { PackedValue = ToBgraPackedValue(b, g, r) };
+                pixelRow[x] = TPixel.FromScaledVector4(bgra.ToScaledVector4());
                 if (x + 1 >= pixelRow.Length)
                 {
                     offset++;
@@ -47,8 +44,7 @@ internal class Rgb444TiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
                 offset++;
 
                 bgra.PackedValue = ToBgraPackedValue(b, g, r);
-                color.FromScaledVector4(bgra.ToScaledVector4());
-                pixelRow[x + 1] = color;
+                pixelRow[x + 1] = TPixel.FromScaledVector4(bgra.ToScaledVector4());
             }
         }
     }
diff --git a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/RgbFloat323232TiffColor{TPixel}.cs b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/RgbFloat323232TiffColor{TPixel}.cs
index 1c3af5562..37605ef80 100644
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/RgbFloat323232TiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/RgbFloat323232TiffColor{TPixel}.cs
@@ -1,7 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System.Numerics;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
 
@@ -10,6 +9,7 @@ namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation;
 /// <summary>
 /// Implements the 'RGB' photometric interpretation with 32 bits for each channel.
 /// </summary>
+/// <typeparam name="TPixel">The type of pixel format.</typeparam>
 internal class RgbFloat323232TiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
     where TPixel : unmanaged, IPixel<TPixel>
 {
@@ -24,8 +24,6 @@ internal class RgbFloat323232TiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
     /// <inheritdoc/>
     public override void Decode(ReadOnlySpan<byte> data, Buffer2D<TPixel> pixels, int left, int top, int width, int height)
     {
-        var color = default(TPixel);
-        color.FromScaledVector4(Vector4.Zero);
         int offset = 0;
         Span<byte> buffer = stackalloc byte[4];
 
@@ -52,9 +50,7 @@ internal class RgbFloat323232TiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
                     float b = BitConverter.ToSingle(buffer);
                     offset += 4;
 
-                    var colorVector = new Vector4(r, g, b, 1.0f);
-                    color.FromScaledVector4(colorVector);
-                    pixelRow[x] = color;
+                    pixelRow[x] = TPixel.FromScaledVector4(new(r, g, b, 1f));
                 }
             }
             else
@@ -70,9 +66,7 @@ internal class RgbFloat323232TiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
                     float b = BitConverter.ToSingle(data.Slice(offset, 4));
                     offset += 4;
 
-                    var colorVector = new Vector4(r, g, b, 1.0f);
-                    color.FromScaledVector4(colorVector);
-                    pixelRow[x] = color;
+                    pixelRow[x] = TPixel.FromScaledVector4(new(r, g, b, 1f));
                 }
             }
         }
diff --git a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/RgbPlanarTiffColor{TPixel}.cs b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/RgbPlanarTiffColor{TPixel}.cs
index 0b822f5a0..844b08d3c 100644
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/RgbPlanarTiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/RgbPlanarTiffColor{TPixel}.cs
@@ -2,7 +2,6 @@
 // Licensed under the Six Labors Split License.
 
 using System.Buffers;
-using System.Numerics;
 using SixLabors.ImageSharp.Formats.Tiff.Utils;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
@@ -12,6 +11,7 @@ namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation;
 /// <summary>
 /// Implements the 'RGB' photometric interpretation with 'Planar' layout (for all bit depths).
 /// </summary>
+/// <typeparam name="TPixel">The type of pixel format.</typeparam>
 internal class RgbPlanarTiffColor<TPixel> : TiffBasePlanarColorDecoder<TPixel>
     where TPixel : unmanaged, IPixel<TPixel>
 {
@@ -49,11 +49,9 @@ internal class RgbPlanarTiffColor<TPixel> : TiffBasePlanarColorDecoder<TPixel>
     /// <param name="height">The height of the image block.</param>
     public override void Decode(IMemoryOwner<byte>[] data, Buffer2D<TPixel> pixels, int left, int top, int width, int height)
     {
-        var color = default(TPixel);
-
-        var rBitReader = new BitReader(data[0].GetSpan());
-        var gBitReader = new BitReader(data[1].GetSpan());
-        var bBitReader = new BitReader(data[2].GetSpan());
+        BitReader rBitReader = new(data[0].GetSpan());
+        BitReader gBitReader = new(data[1].GetSpan());
+        BitReader bBitReader = new(data[2].GetSpan());
 
         for (int y = top; y < top + height; y++)
         {
@@ -64,8 +62,7 @@ internal class RgbPlanarTiffColor<TPixel> : TiffBasePlanarColorDecoder<TPixel>
                 float g = gBitReader.ReadBits(this.bitsPerSampleG) / this.gFactor;
                 float b = bBitReader.ReadBits(this.bitsPerSampleB) / this.bFactor;
 
-                color.FromScaledVector4(new Vector4(r, g, b, 1.0f));
-                pixelRow[x] = color;
+                pixelRow[x] = TPixel.FromScaledVector4(new(r, g, b, 1f));
             }
 
             rBitReader.NextRow();
diff --git a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/RgbTiffColor{TPixel}.cs b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/RgbTiffColor{TPixel}.cs
index dcaab94a6..3c205d147 100644
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/RgbTiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/RgbTiffColor{TPixel}.cs
@@ -11,6 +11,7 @@ namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation;
 /// <summary>
 /// Implements the 'RGB' photometric interpretation (for all bit depths).
 /// </summary>
+/// <typeparam name="TPixel">The type of pixel format.</typeparam>
 internal class RgbTiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
     where TPixel : unmanaged, IPixel<TPixel>
 {
@@ -40,9 +41,7 @@ internal class RgbTiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
     /// <inheritdoc/>
     public override void Decode(ReadOnlySpan<byte> data, Buffer2D<TPixel> pixels, int left, int top, int width, int height)
     {
-        var color = default(TPixel);
-
-        var bitReader = new BitReader(data);
+        BitReader bitReader = new(data);
 
         for (int y = top; y < top + height; y++)
         {
@@ -53,8 +52,7 @@ internal class RgbTiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
                 float g = bitReader.ReadBits(this.bitsPerSampleG) / this.gFactor;
                 float b = bitReader.ReadBits(this.bitsPerSampleB) / this.bFactor;
 
-                color.FromScaledVector4(new Vector4(r, g, b, 1.0f));
-                pixelRow[x] = color;
+                pixelRow[x] = TPixel.FromScaledVector4(new Vector4(r, g, b, 1f));
             }
 
             bitReader.NextRow();
diff --git a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgba16161616TiffColor{TPixel}.cs b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgba16161616TiffColor{TPixel}.cs
index 0467f7ad5..e4965887d 100644
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgba16161616TiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgba16161616TiffColor{TPixel}.cs
@@ -13,6 +13,7 @@ namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation;
 /// <summary>
 /// Implements the 'RGB' photometric interpretation with an alpha channel and with 16 bits for each channel.
 /// </summary>
+/// <typeparam name="TPixel">The type of pixel format.</typeparam>
 internal class Rgba16161616TiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
     where TPixel : unmanaged, IPixel<TPixel>
 {
@@ -29,8 +30,8 @@ internal class Rgba16161616TiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
     /// </summary>
     /// <param name="configuration">The configuration.</param>
     /// <param name="memoryAllocator">The memory allocator.</param>
-    /// <param name="isBigEndian">if set to <c>true</c> decodes the pixel data as big endian, otherwise as little endian.</param>
     /// <param name="extraSamplesType">The type of the extra samples.</param>
+    /// <param name="isBigEndian">if set to <c>true</c> decodes the pixel data as big endian, otherwise as little endian.</param>
     public Rgba16161616TiffColor(Configuration configuration, MemoryAllocator memoryAllocator, TiffExtraSampleType? extraSamplesType, bool isBigEndian)
     {
         this.configuration = configuration;
@@ -42,15 +43,11 @@ internal class Rgba16161616TiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
     /// <inheritdoc/>
     public override void Decode(ReadOnlySpan<byte> data, Buffer2D<TPixel> pixels, int left, int top, int width, int height)
     {
-        Rgba64 rgba = TiffUtils.Rgba64Default;
-        var color = default(TPixel);
-        color.FromScaledVector4(Vector4.Zero);
-
         bool hasAssociatedAlpha = this.extraSamplesType.HasValue && this.extraSamplesType == TiffExtraSampleType.AssociatedAlphaData;
         int offset = 0;
 
         using IMemoryOwner<Vector4> vectors = hasAssociatedAlpha ? this.memoryAllocator.Allocate<Vector4>(width) : null;
-        Span<Vector4> vectorsSpan = hasAssociatedAlpha ? vectors.GetSpan() : Span<Vector4>.Empty;
+        Span<Vector4> vectorsSpan = hasAssociatedAlpha ? vectors.GetSpan() : [];
         for (int y = top; y < top + height; y++)
         {
             Span<TPixel> pixelRow = pixels.DangerousGetRowSpan(y).Slice(left, width);
@@ -59,18 +56,18 @@ internal class Rgba16161616TiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
             {
                 for (int x = 0; x < pixelRow.Length; x++)
                 {
-                    ulong r = TiffUtils.ConvertToUShortBigEndian(data.Slice(offset, 2));
+                    ushort r = TiffUtilities.ConvertToUShortBigEndian(data.Slice(offset, 2));
                     offset += 2;
-                    ulong g = TiffUtils.ConvertToUShortBigEndian(data.Slice(offset, 2));
+                    ushort g = TiffUtilities.ConvertToUShortBigEndian(data.Slice(offset, 2));
                     offset += 2;
-                    ulong b = TiffUtils.ConvertToUShortBigEndian(data.Slice(offset, 2));
+                    ushort b = TiffUtilities.ConvertToUShortBigEndian(data.Slice(offset, 2));
                     offset += 2;
-                    ulong a = TiffUtils.ConvertToUShortBigEndian(data.Slice(offset, 2));
+                    ushort a = TiffUtilities.ConvertToUShortBigEndian(data.Slice(offset, 2));
                     offset += 2;
 
-                    pixelRow[x] = hasAssociatedAlpha ?
-                        TiffUtils.ColorFromRgba64Premultiplied(rgba, r, g, b, a, color) :
-                        TiffUtils.ColorFromRgba64(rgba, r, g, b, a, color);
+                    pixelRow[x] = hasAssociatedAlpha
+                        ? TiffUtilities.ColorFromRgba64Premultiplied<TPixel>(r, g, b, a)
+                        : TPixel.FromRgba64(new(r, g, b, a));
                 }
             }
             else
diff --git a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgba16PlanarTiffColor{TPixel}.cs b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgba16PlanarTiffColor{TPixel}.cs
index 7426544d2..3d36db17d 100644
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgba16PlanarTiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgba16PlanarTiffColor{TPixel}.cs
@@ -2,7 +2,6 @@
 // Licensed under the Six Labors Split License.
 
 using System.Buffers;
-using System.Numerics;
 using SixLabors.ImageSharp.Formats.Tiff.Utils;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
@@ -12,6 +11,7 @@ namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation;
 /// <summary>
 /// Implements the 'RGB' photometric interpretation with an alpha channel and with 'Planar' layout for each color channel with 16 bit.
 /// </summary>
+/// <typeparam name="TPixel">The type of pixel format.</typeparam>
 internal class Rgba16PlanarTiffColor<TPixel> : TiffBasePlanarColorDecoder<TPixel>
     where TPixel : unmanaged, IPixel<TPixel>
 {
@@ -33,10 +33,6 @@ internal class Rgba16PlanarTiffColor<TPixel> : TiffBasePlanarColorDecoder<TPixel
     /// <inheritdoc/>
     public override void Decode(IMemoryOwner<byte>[] data, Buffer2D<TPixel> pixels, int left, int top, int width, int height)
     {
-        Rgba64 rgba = TiffUtils.Rgba64Default;
-        var color = default(TPixel);
-        color.FromScaledVector4(Vector4.Zero);
-
         Span<byte> redData = data[0].GetSpan();
         Span<byte> greenData = data[1].GetSpan();
         Span<byte> blueData = data[2].GetSpan();
@@ -51,32 +47,32 @@ internal class Rgba16PlanarTiffColor<TPixel> : TiffBasePlanarColorDecoder<TPixel
             {
                 for (int x = 0; x < pixelRow.Length; x++)
                 {
-                    ulong r = TiffUtils.ConvertToUShortBigEndian(redData.Slice(offset, 2));
-                    ulong g = TiffUtils.ConvertToUShortBigEndian(greenData.Slice(offset, 2));
-                    ulong b = TiffUtils.ConvertToUShortBigEndian(blueData.Slice(offset, 2));
-                    ulong a = TiffUtils.ConvertToUShortBigEndian(alphaData.Slice(offset, 2));
+                    ushort r = TiffUtilities.ConvertToUShortBigEndian(redData.Slice(offset, 2));
+                    ushort g = TiffUtilities.ConvertToUShortBigEndian(greenData.Slice(offset, 2));
+                    ushort b = TiffUtilities.ConvertToUShortBigEndian(blueData.Slice(offset, 2));
+                    ushort a = TiffUtilities.ConvertToUShortBigEndian(alphaData.Slice(offset, 2));
 
                     offset += 2;
 
-                    pixelRow[x] = hasAssociatedAlpha ?
-                       TiffUtils.ColorFromRgba64Premultiplied(rgba, r, g, b, a, color) :
-                       TiffUtils.ColorFromRgba64(rgba, r, g, b, a, color);
+                    pixelRow[x] = hasAssociatedAlpha
+                        ? TiffUtilities.ColorFromRgba64Premultiplied<TPixel>(r, g, b, a)
+                        : TPixel.FromRgba64(new(r, g, b, a));
                 }
             }
             else
             {
                 for (int x = 0; x < pixelRow.Length; x++)
                 {
-                    ulong r = TiffUtils.ConvertToUShortLittleEndian(redData.Slice(offset, 2));
-                    ulong g = TiffUtils.ConvertToUShortLittleEndian(greenData.Slice(offset, 2));
-                    ulong b = TiffUtils.ConvertToUShortLittleEndian(blueData.Slice(offset, 2));
-                    ulong a = TiffUtils.ConvertToUShortLittleEndian(alphaData.Slice(offset, 2));
+                    ushort r = TiffUtilities.ConvertToUShortLittleEndian(redData.Slice(offset, 2));
+                    ushort g = TiffUtilities.ConvertToUShortLittleEndian(greenData.Slice(offset, 2));
+                    ushort b = TiffUtilities.ConvertToUShortLittleEndian(blueData.Slice(offset, 2));
+                    ushort a = TiffUtilities.ConvertToUShortLittleEndian(alphaData.Slice(offset, 2));
 
                     offset += 2;
 
-                    pixelRow[x] = hasAssociatedAlpha ?
-                        TiffUtils.ColorFromRgba64Premultiplied(rgba, r, g, b, a, color) :
-                        TiffUtils.ColorFromRgba64(rgba, r, g, b, a, color);
+                    pixelRow[x] = hasAssociatedAlpha
+                        ? TiffUtilities.ColorFromRgba64Premultiplied<TPixel>(r, g, b, a)
+                        : TPixel.FromRgba64(new(r, g, b, a));
                 }
             }
         }
diff --git a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgba24242424TiffColor{TPixel}.cs b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgba24242424TiffColor{TPixel}.cs
index eba60679a..a29469365 100644
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgba24242424TiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgba24242424TiffColor{TPixel}.cs
@@ -1,7 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System.Numerics;
 using SixLabors.ImageSharp.Formats.Tiff.Utils;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
@@ -11,6 +10,7 @@ namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation;
 /// <summary>
 /// Implements the 'RGB' photometric interpretation with an alpha channel and with 24 bits for each channel.
 /// </summary>
+/// <typeparam name="TPixel">The type of pixel format.</typeparam>
 internal class Rgba24242424TiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
     where TPixel : unmanaged, IPixel<TPixel>
 {
@@ -32,9 +32,6 @@ internal class Rgba24242424TiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
     /// <inheritdoc/>
     public override void Decode(ReadOnlySpan<byte> data, Buffer2D<TPixel> pixels, int left, int top, int width, int height)
     {
-        var color = default(TPixel);
-        color.FromScaledVector4(Vector4.Zero);
-
         bool hasAssociatedAlpha = this.extraSamplesType.HasValue && this.extraSamplesType == TiffExtraSampleType.AssociatedAlphaData;
         int offset = 0;
 
@@ -51,24 +48,24 @@ internal class Rgba24242424TiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
                 for (int x = 0; x < pixelRow.Length; x++)
                 {
                     data.Slice(offset, 3).CopyTo(bufferSpan);
-                    ulong r = TiffUtils.ConvertToUIntBigEndian(buffer);
+                    uint r = TiffUtilities.ConvertToUIntBigEndian(buffer);
                     offset += 3;
 
                     data.Slice(offset, 3).CopyTo(bufferSpan);
-                    ulong g = TiffUtils.ConvertToUIntBigEndian(buffer);
+                    uint g = TiffUtilities.ConvertToUIntBigEndian(buffer);
                     offset += 3;
 
                     data.Slice(offset, 3).CopyTo(bufferSpan);
-                    ulong b = TiffUtils.ConvertToUIntBigEndian(buffer);
+                    uint b = TiffUtilities.ConvertToUIntBigEndian(buffer);
                     offset += 3;
 
                     data.Slice(offset, 3).CopyTo(bufferSpan);
-                    ulong a = TiffUtils.ConvertToUIntBigEndian(buffer);
+                    uint a = TiffUtilities.ConvertToUIntBigEndian(buffer);
                     offset += 3;
 
-                    pixelRow[x] = hasAssociatedAlpha ?
-                        TiffUtils.ColorScaleTo24BitPremultiplied(r, g, b, a, color) :
-                        TiffUtils.ColorScaleTo24Bit(r, g, b, a, color);
+                    pixelRow[x] = hasAssociatedAlpha
+                        ? TiffUtilities.ColorScaleTo24BitPremultiplied<TPixel>(r, g, b, a)
+                        : TiffUtilities.ColorScaleTo24Bit<TPixel>(r, g, b, a);
                 }
             }
             else
@@ -76,24 +73,24 @@ internal class Rgba24242424TiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
                 for (int x = 0; x < pixelRow.Length; x++)
                 {
                     data.Slice(offset, 3).CopyTo(bufferSpan);
-                    ulong r = TiffUtils.ConvertToUIntLittleEndian(buffer);
+                    uint r = TiffUtilities.ConvertToUIntLittleEndian(buffer);
                     offset += 3;
 
                     data.Slice(offset, 3).CopyTo(bufferSpan);
-                    ulong g = TiffUtils.ConvertToUIntLittleEndian(buffer);
+                    uint g = TiffUtilities.ConvertToUIntLittleEndian(buffer);
                     offset += 3;
 
                     data.Slice(offset, 3).CopyTo(bufferSpan);
-                    ulong b = TiffUtils.ConvertToUIntLittleEndian(buffer);
+                    uint b = TiffUtilities.ConvertToUIntLittleEndian(buffer);
                     offset += 3;
 
                     data.Slice(offset, 3).CopyTo(bufferSpan);
-                    ulong a = TiffUtils.ConvertToUIntLittleEndian(buffer);
+                    uint a = TiffUtilities.ConvertToUIntLittleEndian(buffer);
                     offset += 3;
 
-                    pixelRow[x] = hasAssociatedAlpha ?
-                        TiffUtils.ColorScaleTo24BitPremultiplied(r, g, b, a, color) :
-                        TiffUtils.ColorScaleTo24Bit(r, g, b, a, color);
+                    pixelRow[x] = hasAssociatedAlpha
+                        ? TiffUtilities.ColorScaleTo24BitPremultiplied<TPixel>(r, g, b, a)
+                        : TiffUtilities.ColorScaleTo24Bit<TPixel>(r, g, b, a);
                 }
             }
         }
diff --git a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgba24PlanarTiffColor{TPixel}.cs b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgba24PlanarTiffColor{TPixel}.cs
index 1b842a79b..222e72986 100644
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgba24PlanarTiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgba24PlanarTiffColor{TPixel}.cs
@@ -2,7 +2,6 @@
 // Licensed under the Six Labors Split License.
 
 using System.Buffers;
-using System.Numerics;
 using SixLabors.ImageSharp.Formats.Tiff.Utils;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
@@ -12,6 +11,7 @@ namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation;
 /// <summary>
 /// Implements the 'RGB' photometric interpretation with an alpha channel and with 'Planar' layout for each color channel with 24 bit.
 /// </summary>
+/// <typeparam name="TPixel">The type of pixel format.</typeparam>
 internal class Rgba24PlanarTiffColor<TPixel> : TiffBasePlanarColorDecoder<TPixel>
     where TPixel : unmanaged, IPixel<TPixel>
 {
@@ -33,8 +33,6 @@ internal class Rgba24PlanarTiffColor<TPixel> : TiffBasePlanarColorDecoder<TPixel
     /// <inheritdoc/>
     public override void Decode(IMemoryOwner<byte>[] data, Buffer2D<TPixel> pixels, int left, int top, int width, int height)
     {
-        var color = default(TPixel);
-        color.FromScaledVector4(Vector4.Zero);
         Span<byte> buffer = stackalloc byte[4];
         int bufferStartIdx = this.isBigEndian ? 1 : 0;
 
@@ -54,19 +52,19 @@ internal class Rgba24PlanarTiffColor<TPixel> : TiffBasePlanarColorDecoder<TPixel
                 for (int x = 0; x < pixelRow.Length; x++)
                 {
                     redData.Slice(offset, 3).CopyTo(bufferSpan);
-                    ulong r = TiffUtils.ConvertToUIntBigEndian(buffer);
+                    uint r = TiffUtilities.ConvertToUIntBigEndian(buffer);
                     greenData.Slice(offset, 3).CopyTo(bufferSpan);
-                    ulong g = TiffUtils.ConvertToUIntBigEndian(buffer);
+                    uint g = TiffUtilities.ConvertToUIntBigEndian(buffer);
                     blueData.Slice(offset, 3).CopyTo(bufferSpan);
-                    ulong b = TiffUtils.ConvertToUIntBigEndian(buffer);
+                    uint b = TiffUtilities.ConvertToUIntBigEndian(buffer);
                     alphaData.Slice(offset, 3).CopyTo(bufferSpan);
-                    ulong a = TiffUtils.ConvertToUIntBigEndian(buffer);
+                    uint a = TiffUtilities.ConvertToUIntBigEndian(buffer);
 
                     offset += 3;
 
-                    pixelRow[x] = hasAssociatedAlpha ?
-                        TiffUtils.ColorScaleTo24BitPremultiplied(r, g, b, a, color) :
-                        TiffUtils.ColorScaleTo24Bit(r, g, b, a, color);
+                    pixelRow[x] = hasAssociatedAlpha
+                        ? TiffUtilities.ColorScaleTo24BitPremultiplied<TPixel>(r, g, b, a)
+                        : TiffUtilities.ColorScaleTo24Bit<TPixel>(r, g, b, a);
                 }
             }
             else
@@ -74,19 +72,19 @@ internal class Rgba24PlanarTiffColor<TPixel> : TiffBasePlanarColorDecoder<TPixel
                 for (int x = 0; x < pixelRow.Length; x++)
                 {
                     redData.Slice(offset, 3).CopyTo(bufferSpan);
-                    ulong r = TiffUtils.ConvertToUIntLittleEndian(buffer);
+                    uint r = TiffUtilities.ConvertToUIntLittleEndian(buffer);
                     greenData.Slice(offset, 3).CopyTo(bufferSpan);
-                    ulong g = TiffUtils.ConvertToUIntLittleEndian(buffer);
+                    uint g = TiffUtilities.ConvertToUIntLittleEndian(buffer);
                     blueData.Slice(offset, 3).CopyTo(bufferSpan);
-                    ulong b = TiffUtils.ConvertToUIntLittleEndian(buffer);
+                    uint b = TiffUtilities.ConvertToUIntLittleEndian(buffer);
                     alphaData.Slice(offset, 3).CopyTo(bufferSpan);
-                    ulong a = TiffUtils.ConvertToUIntLittleEndian(buffer);
+                    uint a = TiffUtilities.ConvertToUIntLittleEndian(buffer);
 
                     offset += 3;
 
-                    pixelRow[x] = hasAssociatedAlpha ?
-                        TiffUtils.ColorScaleTo24BitPremultiplied(r, g, b, a, color) :
-                        TiffUtils.ColorScaleTo24Bit(r, g, b, a, color);
+                    pixelRow[x] = hasAssociatedAlpha
+                        ? TiffUtilities.ColorScaleTo24BitPremultiplied<TPixel>(r, g, b, a)
+                        : TiffUtilities.ColorScaleTo24Bit<TPixel>(r, g, b, a);
                 }
             }
         }
diff --git a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgba32323232TiffColor{TPixel}.cs b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgba32323232TiffColor{TPixel}.cs
index 2193f2e81..5c57221d9 100644
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgba32323232TiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgba32323232TiffColor{TPixel}.cs
@@ -1,7 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System.Numerics;
 using SixLabors.ImageSharp.Formats.Tiff.Utils;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
@@ -11,6 +10,7 @@ namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation;
 /// <summary>
 /// Implements the 'RGB' photometric interpretation with an alpha channel and with 32 bits for each channel.
 /// </summary>
+/// <typeparam name="TPixel">The type of pixel format.</typeparam>
 internal class Rgba32323232TiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
     where TPixel : unmanaged, IPixel<TPixel>
 {
@@ -32,9 +32,6 @@ internal class Rgba32323232TiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
     /// <inheritdoc/>
     public override void Decode(ReadOnlySpan<byte> data, Buffer2D<TPixel> pixels, int left, int top, int width, int height)
     {
-        var color = default(TPixel);
-        color.FromScaledVector4(Vector4.Zero);
-
         bool hasAssociatedAlpha = this.extraSamplesType.HasValue && this.extraSamplesType == TiffExtraSampleType.AssociatedAlphaData;
         int offset = 0;
 
@@ -46,42 +43,42 @@ internal class Rgba32323232TiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
             {
                 for (int x = 0; x < pixelRow.Length; x++)
                 {
-                    ulong r = TiffUtils.ConvertToUIntBigEndian(data.Slice(offset, 4));
+                    uint r = TiffUtilities.ConvertToUIntBigEndian(data.Slice(offset, 4));
                     offset += 4;
 
-                    ulong g = TiffUtils.ConvertToUIntBigEndian(data.Slice(offset, 4));
+                    uint g = TiffUtilities.ConvertToUIntBigEndian(data.Slice(offset, 4));
                     offset += 4;
 
-                    ulong b = TiffUtils.ConvertToUIntBigEndian(data.Slice(offset, 4));
+                    uint b = TiffUtilities.ConvertToUIntBigEndian(data.Slice(offset, 4));
                     offset += 4;
 
-                    ulong a = TiffUtils.ConvertToUIntBigEndian(data.Slice(offset, 4));
+                    uint a = TiffUtilities.ConvertToUIntBigEndian(data.Slice(offset, 4));
                     offset += 4;
 
-                    pixelRow[x] = hasAssociatedAlpha ?
-                        TiffUtils.ColorScaleTo32BitPremultiplied(r, g, b, a, color) :
-                        TiffUtils.ColorScaleTo32Bit(r, g, b, a, color);
+                    pixelRow[x] = hasAssociatedAlpha
+                        ? TiffUtilities.ColorScaleTo32BitPremultiplied<TPixel>(r, g, b, a)
+                        : TiffUtilities.ColorScaleTo32Bit<TPixel>(r, g, b, a);
                 }
             }
             else
             {
                 for (int x = 0; x < pixelRow.Length; x++)
                 {
-                    ulong r = TiffUtils.ConvertToUIntLittleEndian(data.Slice(offset, 4));
+                    uint r = TiffUtilities.ConvertToUIntLittleEndian(data.Slice(offset, 4));
                     offset += 4;
 
-                    ulong g = TiffUtils.ConvertToUIntLittleEndian(data.Slice(offset, 4));
+                    uint g = TiffUtilities.ConvertToUIntLittleEndian(data.Slice(offset, 4));
                     offset += 4;
 
-                    ulong b = TiffUtils.ConvertToUIntLittleEndian(data.Slice(offset, 4));
+                    uint b = TiffUtilities.ConvertToUIntLittleEndian(data.Slice(offset, 4));
                     offset += 4;
 
-                    ulong a = TiffUtils.ConvertToUIntLittleEndian(data.Slice(offset, 4));
+                    uint a = TiffUtilities.ConvertToUIntLittleEndian(data.Slice(offset, 4));
                     offset += 4;
 
-                    pixelRow[x] = hasAssociatedAlpha ?
-                       TiffUtils.ColorScaleTo32BitPremultiplied(r, g, b, a, color) :
-                       TiffUtils.ColorScaleTo32Bit(r, g, b, a, color);
+                    pixelRow[x] = hasAssociatedAlpha
+                        ? TiffUtilities.ColorScaleTo32BitPremultiplied<TPixel>(r, g, b, a)
+                        : TiffUtilities.ColorScaleTo32Bit<TPixel>(r, g, b, a);
                 }
             }
         }
diff --git a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgba32PlanarTiffColor{TPixel}.cs b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgba32PlanarTiffColor{TPixel}.cs
index 7d047cf7f..8f9090741 100644
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgba32PlanarTiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgba32PlanarTiffColor{TPixel}.cs
@@ -2,7 +2,6 @@
 // Licensed under the Six Labors Split License.
 
 using System.Buffers;
-using System.Numerics;
 using SixLabors.ImageSharp.Formats.Tiff.Utils;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
@@ -12,11 +11,11 @@ namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation;
 /// <summary>
 /// Implements the 'RGB' photometric interpretation with an alpha channel and a 'Planar' layout for each color channel with 32 bit.
 /// </summary>
+/// <typeparam name="TPixel">The type of pixel format.</typeparam>
 internal class Rgba32PlanarTiffColor<TPixel> : TiffBasePlanarColorDecoder<TPixel>
     where TPixel : unmanaged, IPixel<TPixel>
 {
     private readonly bool isBigEndian;
-
     private readonly TiffExtraSampleType? extraSamplesType;
 
     /// <summary>
@@ -33,9 +32,6 @@ internal class Rgba32PlanarTiffColor<TPixel> : TiffBasePlanarColorDecoder<TPixel
     /// <inheritdoc/>
     public override void Decode(IMemoryOwner<byte>[] data, Buffer2D<TPixel> pixels, int left, int top, int width, int height)
     {
-        var color = default(TPixel);
-        color.FromScaledVector4(Vector4.Zero);
-
         Span<byte> redData = data[0].GetSpan();
         Span<byte> greenData = data[1].GetSpan();
         Span<byte> blueData = data[2].GetSpan();
@@ -50,32 +46,32 @@ internal class Rgba32PlanarTiffColor<TPixel> : TiffBasePlanarColorDecoder<TPixel
             {
                 for (int x = 0; x < pixelRow.Length; x++)
                 {
-                    ulong r = TiffUtils.ConvertToUIntBigEndian(redData.Slice(offset, 4));
-                    ulong g = TiffUtils.ConvertToUIntBigEndian(greenData.Slice(offset, 4));
-                    ulong b = TiffUtils.ConvertToUIntBigEndian(blueData.Slice(offset, 4));
-                    ulong a = TiffUtils.ConvertToUIntBigEndian(alphaData.Slice(offset, 4));
+                    uint r = TiffUtilities.ConvertToUIntBigEndian(redData.Slice(offset, 4));
+                    uint g = TiffUtilities.ConvertToUIntBigEndian(greenData.Slice(offset, 4));
+                    uint b = TiffUtilities.ConvertToUIntBigEndian(blueData.Slice(offset, 4));
+                    uint a = TiffUtilities.ConvertToUIntBigEndian(alphaData.Slice(offset, 4));
 
                     offset += 4;
 
-                    pixelRow[x] = hasAssociatedAlpha ?
-                        TiffUtils.ColorScaleTo32BitPremultiplied(r, g, b, a, color) :
-                        TiffUtils.ColorScaleTo32Bit(r, g, b, a, color);
+                    pixelRow[x] = hasAssociatedAlpha
+                        ? TiffUtilities.ColorScaleTo32BitPremultiplied<TPixel>(r, g, b, a)
+                        : TiffUtilities.ColorScaleTo32Bit<TPixel>(r, g, b, a);
                 }
             }
             else
             {
                 for (int x = 0; x < pixelRow.Length; x++)
                 {
-                    ulong r = TiffUtils.ConvertToUIntLittleEndian(redData.Slice(offset, 4));
-                    ulong g = TiffUtils.ConvertToUIntLittleEndian(greenData.Slice(offset, 4));
-                    ulong b = TiffUtils.ConvertToUIntLittleEndian(blueData.Slice(offset, 4));
-                    ulong a = TiffUtils.ConvertToUIntLittleEndian(alphaData.Slice(offset, 4));
+                    uint r = TiffUtilities.ConvertToUIntLittleEndian(redData.Slice(offset, 4));
+                    uint g = TiffUtilities.ConvertToUIntLittleEndian(greenData.Slice(offset, 4));
+                    uint b = TiffUtilities.ConvertToUIntLittleEndian(blueData.Slice(offset, 4));
+                    uint a = TiffUtilities.ConvertToUIntLittleEndian(alphaData.Slice(offset, 4));
 
                     offset += 4;
 
-                    pixelRow[x] = hasAssociatedAlpha ?
-                        TiffUtils.ColorScaleTo32BitPremultiplied(r, g, b, a, color) :
-                        TiffUtils.ColorScaleTo32Bit(r, g, b, a, color);
+                    pixelRow[x] = hasAssociatedAlpha
+                        ? TiffUtilities.ColorScaleTo32BitPremultiplied<TPixel>(r, g, b, a)
+                        : TiffUtilities.ColorScaleTo32Bit<TPixel>(r, g, b, a);
                 }
             }
         }
diff --git a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgba8888TiffColor{TPixel}.cs b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgba8888TiffColor{TPixel}.cs
index dc1fbb871..26ffbbab9 100644
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgba8888TiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgba8888TiffColor{TPixel}.cs
@@ -12,6 +12,7 @@ namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation;
 /// <summary>
 /// Implements the 'RGB' photometric interpretation with an alpha channel and 8 bits per channel.
 /// </summary>
+/// <typeparam name="TPixel">The type of pixel format.</typeparam>
 internal class Rgba8888TiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
     where TPixel : unmanaged, IPixel<TPixel>
 {
@@ -34,10 +35,8 @@ internal class Rgba8888TiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
         int offset = 0;
         bool hasAssociatedAlpha = this.extraSamplesType.HasValue && this.extraSamplesType == TiffExtraSampleType.AssociatedAlphaData;
 
-        var color = default(TPixel);
-        color.FromScaledVector4(Vector4.Zero);
         using IMemoryOwner<Vector4> vectors = hasAssociatedAlpha ? this.memoryAllocator.Allocate<Vector4>(width) : null;
-        Span<Vector4> vectorsSpan = hasAssociatedAlpha ? vectors.GetSpan() : Span<Vector4>.Empty;
+        Span<Vector4> vectorsSpan = hasAssociatedAlpha ? vectors.GetSpan() : [];
         for (int y = top; y < top + height; y++)
         {
             Span<TPixel> pixelRow = pixels.DangerousGetRowSpan(y).Slice(left, width);
diff --git a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/RgbaFloat32323232TiffColor{TPixel}.cs b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/RgbaFloat32323232TiffColor{TPixel}.cs
index 743502d56..12f1b75b4 100644
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/RgbaFloat32323232TiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/RgbaFloat32323232TiffColor{TPixel}.cs
@@ -1,7 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System.Numerics;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
 
@@ -10,6 +9,7 @@ namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation;
 /// <summary>
 /// Implements the 'RGB' photometric interpretation with an alpha channel and with 32 bits for each channel.
 /// </summary>
+/// <typeparam name="TPixel">The type of pixel format.</typeparam>
 internal class RgbaFloat32323232TiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
     where TPixel : unmanaged, IPixel<TPixel>
 {
@@ -24,8 +24,6 @@ internal class RgbaFloat32323232TiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
     /// <inheritdoc/>
     public override void Decode(ReadOnlySpan<byte> data, Buffer2D<TPixel> pixels, int left, int top, int width, int height)
     {
-        var color = default(TPixel);
-        color.FromScaledVector4(Vector4.Zero);
         int offset = 0;
         Span<byte> buffer = stackalloc byte[4];
 
@@ -57,9 +55,7 @@ internal class RgbaFloat32323232TiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
                     float a = BitConverter.ToSingle(buffer);
                     offset += 4;
 
-                    var colorVector = new Vector4(r, g, b, a);
-                    color.FromScaledVector4(colorVector);
-                    pixelRow[x] = color;
+                    pixelRow[x] = TPixel.FromScaledVector4(new(r, g, b, a));
                 }
             }
             else
@@ -78,9 +74,7 @@ internal class RgbaFloat32323232TiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
                     float a = BitConverter.ToSingle(data.Slice(offset, 4));
                     offset += 4;
 
-                    var colorVector = new Vector4(r, g, b, a);
-                    color.FromScaledVector4(colorVector);
-                    pixelRow[x] = color;
+                    pixelRow[x] = TPixel.FromScaledVector4(new(r, g, b, a));
                 }
             }
         }
diff --git a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/RgbaPlanarTiffColor{TPixel}.cs b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/RgbaPlanarTiffColor{TPixel}.cs
index 63aa64d86..7a599a06a 100644
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/RgbaPlanarTiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/RgbaPlanarTiffColor{TPixel}.cs
@@ -12,6 +12,7 @@ namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation;
 /// <summary>
 /// Implements the 'RGB' photometric interpretation with an alpha channel and with 'Planar' layout (for all bit depths).
 /// </summary>
+/// <typeparam name="TPixel">The type of pixel format.</typeparam>
 internal class RgbaPlanarTiffColor<TPixel> : TiffBasePlanarColorDecoder<TPixel>
     where TPixel : unmanaged, IPixel<TPixel>
 {
@@ -59,13 +60,12 @@ internal class RgbaPlanarTiffColor<TPixel> : TiffBasePlanarColorDecoder<TPixel>
     /// <param name="height">The height of the image block.</param>
     public override void Decode(IMemoryOwner<byte>[] data, Buffer2D<TPixel> pixels, int left, int top, int width, int height)
     {
-        var color = default(TPixel);
         bool hasAssociatedAlpha = this.extraSampleType.HasValue && this.extraSampleType == TiffExtraSampleType.AssociatedAlphaData;
 
-        var rBitReader = new BitReader(data[0].GetSpan());
-        var gBitReader = new BitReader(data[1].GetSpan());
-        var bBitReader = new BitReader(data[2].GetSpan());
-        var aBitReader = new BitReader(data[3].GetSpan());
+        BitReader rBitReader = new(data[0].GetSpan());
+        BitReader gBitReader = new(data[1].GetSpan());
+        BitReader bBitReader = new(data[2].GetSpan());
+        BitReader aBitReader = new(data[3].GetSpan());
 
         for (int y = top; y < top + height; y++)
         {
@@ -77,17 +77,15 @@ internal class RgbaPlanarTiffColor<TPixel> : TiffBasePlanarColorDecoder<TPixel>
                 float b = bBitReader.ReadBits(this.bitsPerSampleB) / this.bFactor;
                 float a = aBitReader.ReadBits(this.bitsPerSampleA) / this.aFactor;
 
-                var vec = new Vector4(r, g, b, a);
+                Vector4 vector = new(r, g, b, a);
                 if (hasAssociatedAlpha)
                 {
-                    color = TiffUtils.UnPremultiply(ref vec, color);
+                    pixelRow[x] = TiffUtilities.UnPremultiply<TPixel>(ref vector);
                 }
                 else
                 {
-                    color.FromScaledVector4(vec);
+                    pixelRow[x] = TPixel.FromScaledVector4(vector);
                 }
-
-                pixelRow[x] = color;
             }
 
             rBitReader.NextRow();
diff --git a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/RgbaTiffColor{TPixel}.cs b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/RgbaTiffColor{TPixel}.cs
index 0ea8a87fc..68b59c95a 100644
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/RgbaTiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/RgbaTiffColor{TPixel}.cs
@@ -11,6 +11,7 @@ namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation;
 /// <summary>
 /// Implements the 'RGB' photometric interpretation with alpha channel (for all bit depths).
 /// </summary>
+/// <typeparam name="TPixel">The type of pixel format.</typeparam>
 internal class RgbaTiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
     where TPixel : unmanaged, IPixel<TPixel>
 {
@@ -50,9 +51,7 @@ internal class RgbaTiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
     /// <inheritdoc/>
     public override void Decode(ReadOnlySpan<byte> data, Buffer2D<TPixel> pixels, int left, int top, int width, int height)
     {
-        var color = default(TPixel);
-
-        var bitReader = new BitReader(data);
+        BitReader bitReader = new(data);
 
         bool hasAssociatedAlpha = this.extraSamplesType.HasValue && this.extraSamplesType == TiffExtraSampleType.AssociatedAlphaData;
 
@@ -66,15 +65,14 @@ internal class RgbaTiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
                 float b = bitReader.ReadBits(this.bitsPerSampleB) / this.bFactor;
                 float a = bitReader.ReadBits(this.bitsPerSampleB) / this.aFactor;
 
-                var vec = new Vector4(r, g, b, a);
+                Vector4 vector = new(r, g, b, a);
                 if (hasAssociatedAlpha)
                 {
-                    pixelRow[x] = TiffUtils.UnPremultiply(ref vec, color);
+                    pixelRow[x] = TiffUtilities.UnPremultiply<TPixel>(ref vector);
                 }
                 else
                 {
-                    color.FromScaledVector4(vec);
-                    pixelRow[x] = color;
+                    pixelRow[x] = TPixel.FromScaledVector4(vector);
                 }
             }
 
diff --git a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/WhiteIsZero16TiffColor{TPixel}.cs b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/WhiteIsZero16TiffColor{TPixel}.cs
index f7fd55e52..6f1672e1b 100644
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/WhiteIsZero16TiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/WhiteIsZero16TiffColor{TPixel}.cs
@@ -1,7 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System.Numerics;
 using SixLabors.ImageSharp.Formats.Tiff.Utils;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
@@ -11,6 +10,7 @@ namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation;
 /// <summary>
 /// Implements the 'WhiteIsZero' photometric interpretation for 16-bit grayscale images.
 /// </summary>
+/// <typeparam name="TPixel">The type of pixel format.</typeparam>
 internal class WhiteIsZero16TiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
     where TPixel : unmanaged, IPixel<TPixel>
 {
@@ -25,10 +25,6 @@ internal class WhiteIsZero16TiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
     /// <inheritdoc/>
     public override void Decode(ReadOnlySpan<byte> data, Buffer2D<TPixel> pixels, int left, int top, int width, int height)
     {
-        L16 l16 = TiffUtils.L16Default;
-        var color = default(TPixel);
-        color.FromScaledVector4(Vector4.Zero);
-
         int offset = 0;
         for (int y = top; y < top + height; y++)
         {
@@ -37,20 +33,20 @@ internal class WhiteIsZero16TiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
             {
                 for (int x = 0; x < pixelRow.Length; x++)
                 {
-                    ushort intensity = (ushort)(ushort.MaxValue - TiffUtils.ConvertToUShortBigEndian(data.Slice(offset, 2)));
+                    ushort intensity = (ushort)(ushort.MaxValue - TiffUtilities.ConvertToUShortBigEndian(data.Slice(offset, 2)));
                     offset += 2;
 
-                    pixelRow[x] = TiffUtils.ColorFromL16(l16, intensity, color);
+                    pixelRow[x] = TPixel.FromL16(new(intensity));
                 }
             }
             else
             {
                 for (int x = 0; x < pixelRow.Length; x++)
                 {
-                    ushort intensity = (ushort)(ushort.MaxValue - TiffUtils.ConvertToUShortLittleEndian(data.Slice(offset, 2)));
+                    ushort intensity = (ushort)(ushort.MaxValue - TiffUtilities.ConvertToUShortLittleEndian(data.Slice(offset, 2)));
                     offset += 2;
 
-                    pixelRow[x] = TiffUtils.ColorFromL16(l16, intensity, color);
+                    pixelRow[x] = TPixel.FromL16(new(intensity));
                 }
             }
         }
diff --git a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/WhiteIsZero1TiffColor{TPixel}.cs b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/WhiteIsZero1TiffColor{TPixel}.cs
index c5b662979..1de9c295b 100644
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/WhiteIsZero1TiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/WhiteIsZero1TiffColor{TPixel}.cs
@@ -11,6 +11,7 @@ namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation;
 /// <summary>
 /// Implements the 'WhiteIsZero' photometric interpretation (optimized for bilevel images).
 /// </summary>
+/// <typeparam name="TPixel">The type of pixel format.</typeparam>
 internal class WhiteIsZero1TiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
     where TPixel : unmanaged, IPixel<TPixel>
 {
@@ -18,11 +19,9 @@ internal class WhiteIsZero1TiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
     public override void Decode(ReadOnlySpan<byte> data, Buffer2D<TPixel> pixels, int left, int top, int width, int height)
     {
         nuint offset = 0;
-        var colorBlack = default(TPixel);
-        var colorWhite = default(TPixel);
+        TPixel colorBlack = TPixel.FromRgba32(Color.Black.ToPixel<Rgba32>());
+        TPixel colorWhite = TPixel.FromRgba32(Color.White.ToPixel<Rgba32>());
 
-        colorBlack.FromRgba32(Color.Black);
-        colorWhite.FromRgba32(Color.White);
         ref byte dataRef = ref MemoryMarshal.GetReference(data);
         for (nuint y = (uint)top; y < (uint)(top + height); y++)
         {
diff --git a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/WhiteIsZero24TiffColor{TPixel}.cs b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/WhiteIsZero24TiffColor{TPixel}.cs
index 59e0df87d..94549d663 100644
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/WhiteIsZero24TiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/WhiteIsZero24TiffColor{TPixel}.cs
@@ -1,7 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System.Numerics;
 using SixLabors.ImageSharp.Formats.Tiff.Utils;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
@@ -11,6 +10,7 @@ namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation;
 /// <summary>
 /// Implements the 'WhiteIsZero' photometric interpretation for 24-bit grayscale images.
 /// </summary>
+/// <typeparam name="TPixel">The type of pixel format.</typeparam>
 internal class WhiteIsZero24TiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
     where TPixel : unmanaged, IPixel<TPixel>
 {
@@ -25,8 +25,6 @@ internal class WhiteIsZero24TiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
     /// <inheritdoc/>
     public override void Decode(ReadOnlySpan<byte> data, Buffer2D<TPixel> pixels, int left, int top, int width, int height)
     {
-        var color = default(TPixel);
-        color.FromScaledVector4(Vector4.Zero);
         Span<byte> buffer = stackalloc byte[4];
         int bufferStartIdx = this.isBigEndian ? 1 : 0;
         const uint maxValue = 0xFFFFFF;
@@ -41,10 +39,10 @@ internal class WhiteIsZero24TiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
                 for (int x = 0; x < pixelRow.Length; x++)
                 {
                     data.Slice(offset, 3).CopyTo(bufferSpan);
-                    ulong intensity = maxValue - TiffUtils.ConvertToUIntBigEndian(buffer);
+                    uint intensity = maxValue - TiffUtilities.ConvertToUIntBigEndian(buffer);
                     offset += 3;
 
-                    pixelRow[x] = TiffUtils.ColorScaleTo24Bit(intensity, color);
+                    pixelRow[x] = TiffUtilities.ColorScaleTo24Bit<TPixel>(intensity);
                 }
             }
             else
@@ -52,10 +50,10 @@ internal class WhiteIsZero24TiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
                 for (int x = 0; x < pixelRow.Length; x++)
                 {
                     data.Slice(offset, 3).CopyTo(bufferSpan);
-                    ulong intensity = maxValue - TiffUtils.ConvertToUIntLittleEndian(buffer);
+                    uint intensity = maxValue - TiffUtilities.ConvertToUIntLittleEndian(buffer);
                     offset += 3;
 
-                    pixelRow[x] = TiffUtils.ColorScaleTo24Bit(intensity, color);
+                    pixelRow[x] = TiffUtilities.ColorScaleTo24Bit<TPixel>(intensity);
                 }
             }
         }
diff --git a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/WhiteIsZero32FloatTiffColor{TPixel}.cs b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/WhiteIsZero32FloatTiffColor{TPixel}.cs
index f3207b2f4..7d31f23ab 100644
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/WhiteIsZero32FloatTiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/WhiteIsZero32FloatTiffColor{TPixel}.cs
@@ -10,6 +10,7 @@ namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation;
 /// <summary>
 /// Implements the 'WhiteIsZero' photometric interpretation for 32-bit float grayscale images.
 /// </summary>
+/// <typeparam name="TPixel">The type of pixel format.</typeparam>
 internal class WhiteIsZero32FloatTiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
     where TPixel : unmanaged, IPixel<TPixel>
 {
@@ -24,8 +25,6 @@ internal class WhiteIsZero32FloatTiffColor<TPixel> : TiffBaseColorDecoder<TPixel
     /// <inheritdoc/>
     public override void Decode(ReadOnlySpan<byte> data, Buffer2D<TPixel> pixels, int left, int top, int width, int height)
     {
-        var color = default(TPixel);
-        color.FromScaledVector4(Vector4.Zero);
         Span<byte> buffer = stackalloc byte[4];
 
         int offset = 0;
@@ -41,9 +40,7 @@ internal class WhiteIsZero32FloatTiffColor<TPixel> : TiffBaseColorDecoder<TPixel
                     float intensity = 1.0f - BitConverter.ToSingle(buffer);
                     offset += 4;
 
-                    var colorVector = new Vector4(intensity, intensity, intensity, 1.0f);
-                    color.FromScaledVector4(colorVector);
-                    pixelRow[x] = color;
+                    pixelRow[x] = TPixel.FromScaledVector4(new(intensity, intensity, intensity, 1f));
                 }
             }
             else
@@ -53,9 +50,7 @@ internal class WhiteIsZero32FloatTiffColor<TPixel> : TiffBaseColorDecoder<TPixel
                     float intensity = 1.0f - BitConverter.ToSingle(data.Slice(offset, 4));
                     offset += 4;
 
-                    var colorVector = new Vector4(intensity, intensity, intensity, 1.0f);
-                    color.FromScaledVector4(colorVector);
-                    pixelRow[x] = color;
+                    pixelRow[x] = TPixel.FromScaledVector4(new Vector4(intensity, intensity, intensity, 1.0f));
                 }
             }
         }
diff --git a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/WhiteIsZero32TiffColor{TPixel}.cs b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/WhiteIsZero32TiffColor{TPixel}.cs
index 558779a14..5a9aba836 100644
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/WhiteIsZero32TiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/WhiteIsZero32TiffColor{TPixel}.cs
@@ -1,7 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System.Numerics;
 using SixLabors.ImageSharp.Formats.Tiff.Utils;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
@@ -11,6 +10,7 @@ namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation;
 /// <summary>
 /// Implements the 'WhiteIsZero' photometric interpretation for 32-bit grayscale images.
 /// </summary>
+/// <typeparam name="TPixel">The type of pixel format.</typeparam>
 internal class WhiteIsZero32TiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
     where TPixel : unmanaged, IPixel<TPixel>
 {
@@ -25,8 +25,6 @@ internal class WhiteIsZero32TiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
     /// <inheritdoc/>
     public override void Decode(ReadOnlySpan<byte> data, Buffer2D<TPixel> pixels, int left, int top, int width, int height)
     {
-        var color = default(TPixel);
-        color.FromScaledVector4(Vector4.Zero);
         const uint maxValue = 0xFFFFFFFF;
 
         int offset = 0;
@@ -37,20 +35,20 @@ internal class WhiteIsZero32TiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
             {
                 for (int x = 0; x < pixelRow.Length; x++)
                 {
-                    ulong intensity = maxValue - TiffUtils.ConvertToUIntBigEndian(data.Slice(offset, 4));
+                    uint intensity = maxValue - TiffUtilities.ConvertToUIntBigEndian(data.Slice(offset, 4));
                     offset += 4;
 
-                    pixelRow[x] = TiffUtils.ColorScaleTo32Bit(intensity, color);
+                    pixelRow[x] = TiffUtilities.ColorScaleTo32Bit<TPixel>(intensity);
                 }
             }
             else
             {
                 for (int x = 0; x < pixelRow.Length; x++)
                 {
-                    ulong intensity = maxValue - TiffUtils.ConvertToUIntLittleEndian(data.Slice(offset, 4));
+                    uint intensity = maxValue - TiffUtilities.ConvertToUIntLittleEndian(data.Slice(offset, 4));
                     offset += 4;
 
-                    pixelRow[x] = TiffUtils.ColorScaleTo32Bit(intensity, color);
+                    pixelRow[x] = TiffUtilities.ColorScaleTo32Bit<TPixel>(intensity);
                 }
             }
         }
diff --git a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/WhiteIsZero4TiffColor{TPixel}.cs b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/WhiteIsZero4TiffColor{TPixel}.cs
index bc5e2fb64..7dcbe23c5 100644
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/WhiteIsZero4TiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/WhiteIsZero4TiffColor{TPixel}.cs
@@ -9,47 +9,30 @@ namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation;
 /// <summary>
 /// Implements the 'WhiteIsZero' photometric interpretation (optimized for 4-bit grayscale images).
 /// </summary>
+/// <typeparam name="TPixel">The type of pixel format.</typeparam>
 internal class WhiteIsZero4TiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
     where TPixel : unmanaged, IPixel<TPixel>
 {
     /// <inheritdoc/>
     public override void Decode(ReadOnlySpan<byte> data, Buffer2D<TPixel> pixels, int left, int top, int width, int height)
     {
-        var color = default(TPixel);
-
         int offset = 0;
         bool isOddWidth = (width & 1) == 1;
 
-        var l8 = default(L8);
         for (int y = top; y < top + height; y++)
         {
             Span<TPixel> pixelRowSpan = pixels.DangerousGetRowSpan(y);
             for (int x = left; x < left + width - 1;)
             {
                 byte byteData = data[offset++];
-
-                byte intensity1 = (byte)((15 - ((byteData & 0xF0) >> 4)) * 17);
-                l8.PackedValue = intensity1;
-                color.FromL8(l8);
-
-                pixelRowSpan[x++] = color;
-
-                byte intensity2 = (byte)((15 - (byteData & 0x0F)) * 17);
-                l8.PackedValue = intensity2;
-                color.FromL8(l8);
-
-                pixelRowSpan[x++] = color;
+                pixelRowSpan[x++] = TPixel.FromL8(new((byte)((15 - ((byteData & 0xF0) >> 4)) * 17)));
+                pixelRowSpan[x++] = TPixel.FromL8(new((byte)((15 - (byteData & 0x0F)) * 17)));
             }
 
             if (isOddWidth)
             {
                 byte byteData = data[offset++];
-
-                byte intensity1 = (byte)((15 - ((byteData & 0xF0) >> 4)) * 17);
-                l8.PackedValue = intensity1;
-                color.FromL8(l8);
-
-                pixelRowSpan[left + width - 1] = color;
+                pixelRowSpan[left + width - 1] = TPixel.FromL8(new((byte)((15 - ((byteData & 0xF0) >> 4)) * 17)));
             }
         }
     }
diff --git a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/WhiteIsZero8TiffColor{TPixel}.cs b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/WhiteIsZero8TiffColor{TPixel}.cs
index fb2653543..5429dbd3b 100644
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/WhiteIsZero8TiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/WhiteIsZero8TiffColor{TPixel}.cs
@@ -1,7 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using SixLabors.ImageSharp.Formats.Tiff.Utils;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
 
@@ -10,24 +9,21 @@ namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation;
 /// <summary>
 /// Implements the 'WhiteIsZero' photometric interpretation (optimized for 8-bit grayscale images).
 /// </summary>
+/// <typeparam name="TPixel">The type of pixel format.</typeparam>
 internal class WhiteIsZero8TiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
     where TPixel : unmanaged, IPixel<TPixel>
 {
     /// <inheritdoc/>
     public override void Decode(ReadOnlySpan<byte> data, Buffer2D<TPixel> pixels, int left, int top, int width, int height)
     {
-        var color = default(TPixel);
-
         int offset = 0;
-
-        var l8 = default(L8);
         for (int y = top; y < top + height; y++)
         {
             Span<TPixel> pixelRow = pixels.DangerousGetRowSpan(y).Slice(left, width);
             for (int x = 0; x < pixelRow.Length; x++)
             {
                 byte intensity = (byte)(byte.MaxValue - data[offset++]);
-                pixelRow[x] = TiffUtils.ColorFromL8(l8, intensity, color);
+                pixelRow[x] = TPixel.FromL8(new(intensity));
             }
         }
     }
diff --git a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/WhiteIsZeroTiffColor{TPixel}.cs b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/WhiteIsZeroTiffColor{TPixel}.cs
index b38868a0e..0cd01a619 100644
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/WhiteIsZeroTiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/WhiteIsZeroTiffColor{TPixel}.cs
@@ -11,11 +11,11 @@ namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation;
 /// <summary>
 /// Implements the 'WhiteIsZero' photometric interpretation (for all bit depths).
 /// </summary>
+/// <typeparam name="TPixel">The type of pixel format.</typeparam>
 internal class WhiteIsZeroTiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
     where TPixel : unmanaged, IPixel<TPixel>
 {
     private readonly ushort bitsPerSample0;
-
     private readonly float factor;
 
     public WhiteIsZeroTiffColor(TiffBitsPerSample bitsPerSample)
@@ -27,9 +27,7 @@ internal class WhiteIsZeroTiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
     /// <inheritdoc/>
     public override void Decode(ReadOnlySpan<byte> data, Buffer2D<TPixel> pixels, int left, int top, int width, int height)
     {
-        var color = default(TPixel);
-
-        var bitReader = new BitReader(data);
+        BitReader bitReader = new(data);
 
         for (int y = top; y < top + height; y++)
         {
@@ -37,10 +35,8 @@ internal class WhiteIsZeroTiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
             for (int x = 0; x < pixelRow.Length; x++)
             {
                 int value = bitReader.ReadBits(this.bitsPerSample0);
-                float intensity = 1.0f - (value / this.factor);
-
-                color.FromScaledVector4(new Vector4(intensity, intensity, intensity, 1.0f));
-                pixelRow[x] = color;
+                float intensity = 1f - (value / this.factor);
+                pixelRow[x] = TPixel.FromScaledVector4(new Vector4(intensity, intensity, intensity, 1f));
             }
 
             bitReader.NextRow();
diff --git a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/YCbCrPlanarTiffColor{TPixel}.cs b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/YCbCrPlanarTiffColor{TPixel}.cs
index 791bfa438..768177bfc 100644
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/YCbCrPlanarTiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/YCbCrPlanarTiffColor{TPixel}.cs
@@ -11,11 +11,11 @@ namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation;
 /// <summary>
 /// Implements decoding pixel data with photometric interpretation of type 'YCbCr' with the planar configuration.
 /// </summary>
+/// <typeparam name="TPixel">The type of pixel format.</typeparam>
 internal class YCbCrPlanarTiffColor<TPixel> : TiffBasePlanarColorDecoder<TPixel>
     where TPixel : unmanaged, IPixel<TPixel>
 {
     private readonly YCbCrConverter converter;
-
     private readonly ushort[] ycbcrSubSampling;
 
     public YCbCrPlanarTiffColor(Rational[] referenceBlackAndWhite, Rational[] coefficients, ushort[] ycbcrSubSampling)
@@ -36,13 +36,12 @@ internal class YCbCrPlanarTiffColor<TPixel> : TiffBasePlanarColorDecoder<TPixel>
             ReverseChromaSubSampling(width, height, this.ycbcrSubSampling[0], this.ycbcrSubSampling[1], cbData, crData);
         }
 
-        var color = default(TPixel);
         int offset = 0;
         int widthPadding = 0;
         if (this.ycbcrSubSampling != null)
         {
             // Round to the next integer multiple of horizontalSubSampling.
-            widthPadding = TiffUtils.PaddingToNextInteger(width, this.ycbcrSubSampling[0]);
+            widthPadding = TiffUtilities.PaddingToNextInteger(width, this.ycbcrSubSampling[0]);
         }
 
         for (int y = top; y < top + height; y++)
@@ -51,8 +50,7 @@ internal class YCbCrPlanarTiffColor<TPixel> : TiffBasePlanarColorDecoder<TPixel>
             for (int x = 0; x < pixelRow.Length; x++)
             {
                 Rgba32 rgba = this.converter.ConvertToRgba32(yData[offset], cbData[offset], crData[offset]);
-                color.FromRgba32(rgba);
-                pixelRow[x] = color;
+                pixelRow[x] = TPixel.FromRgba32(rgba);
                 offset++;
             }
 
@@ -64,8 +62,8 @@ internal class YCbCrPlanarTiffColor<TPixel> : TiffBasePlanarColorDecoder<TPixel>
     {
         // If width and height are not multiples of ChromaSubsampleHoriz and ChromaSubsampleVert respectively,
         // then the source data will be padded.
-        width += TiffUtils.PaddingToNextInteger(width, horizontalSubSampling);
-        height += TiffUtils.PaddingToNextInteger(height, verticalSubSampling);
+        width += TiffUtilities.PaddingToNextInteger(width, horizontalSubSampling);
+        height += TiffUtilities.PaddingToNextInteger(height, verticalSubSampling);
 
         for (int row = height - 1; row >= 0; row--)
         {
diff --git a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/YCbCrTiffColor{TPixel}.cs b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/YCbCrTiffColor{TPixel}.cs
index 2e47698a6..5a1389035 100644
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/YCbCrTiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/YCbCrTiffColor{TPixel}.cs
@@ -11,6 +11,7 @@ namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation;
 /// <summary>
 /// Implements decoding pixel data with photometric interpretation of type 'YCbCr'.
 /// </summary>
+/// <typeparam name="TPixel">The type of pixel format.</typeparam>
 internal class YCbCrTiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
     where TPixel : unmanaged, IPixel<TPixel>
 {
@@ -50,13 +51,12 @@ internal class YCbCrTiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
 
     private void DecodeYCbCrData(Buffer2D<TPixel> pixels, int left, int top, int width, int height, ReadOnlySpan<byte> ycbcrData)
     {
-        var color = default(TPixel);
         int offset = 0;
         int widthPadding = 0;
         if (this.ycbcrSubSampling != null)
         {
             // Round to the next integer multiple of horizontalSubSampling.
-            widthPadding = TiffUtils.PaddingToNextInteger(width, this.ycbcrSubSampling[0]);
+            widthPadding = TiffUtilities.PaddingToNextInteger(width, this.ycbcrSubSampling[0]);
         }
 
         for (int y = top; y < top + height; y++)
@@ -65,8 +65,7 @@ internal class YCbCrTiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
             for (int x = 0; x < pixelRow.Length; x++)
             {
                 Rgba32 rgba = this.converter.ConvertToRgba32(ycbcrData[offset], ycbcrData[offset + 1], ycbcrData[offset + 2]);
-                color.FromRgba32(rgba);
-                pixelRow[x] = color;
+                pixelRow[x] = TPixel.FromRgba32(rgba);
                 offset += 3;
             }
 
@@ -78,8 +77,8 @@ internal class YCbCrTiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
     {
         // If width and height are not multiples of ChromaSubsampleHoriz and ChromaSubsampleVert respectively,
         // then the source data will be padded.
-        width += TiffUtils.PaddingToNextInteger(width, horizontalSubSampling);
-        height += TiffUtils.PaddingToNextInteger(height, verticalSubSampling);
+        width += TiffUtilities.PaddingToNextInteger(width, horizontalSubSampling);
+        height += TiffUtilities.PaddingToNextInteger(height, verticalSubSampling);
         int blockWidth = width / horizontalSubSampling;
         int blockHeight = height / verticalSubSampling;
         int cbCrOffsetInBlock = horizontalSubSampling * verticalSubSampling;
diff --git a/src/ImageSharp/Formats/Tiff/TiffDecoderCore.cs b/src/ImageSharp/Formats/Tiff/TiffDecoderCore.cs
index aed6d4ec6..63dc62399 100644
--- a/src/ImageSharp/Formats/Tiff/TiffDecoderCore.cs
+++ b/src/ImageSharp/Formats/Tiff/TiffDecoderCore.cs
@@ -163,8 +163,8 @@ internal class TiffDecoderCore : IImageDecoderInternals
     public Image<TPixel> Decode<TPixel>(BufferedReadStream stream, CancellationToken cancellationToken)
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        List<ImageFrame<TPixel>> frames = new();
-        List<ImageFrameMetadata> framesMetadata = new();
+        List<ImageFrame<TPixel>> frames = [];
+        List<ImageFrameMetadata> framesMetadata = [];
         try
         {
             this.inputStream = stream;
@@ -221,7 +221,7 @@ internal class TiffDecoderCore : IImageDecoderInternals
         DirectoryReader reader = new(stream, this.configuration.MemoryAllocator);
         IList<ExifProfile> directories = reader.Read();
 
-        List<ImageFrameMetadata> framesMetadata = new();
+        List<ImageFrameMetadata> framesMetadata = [];
         foreach (ExifProfile dir in directories)
         {
             framesMetadata.Add(this.CreateFrameMetadata(dir));
diff --git a/src/ImageSharp/Formats/Tiff/Utils/TiffUtilities.cs b/src/ImageSharp/Formats/Tiff/Utils/TiffUtilities.cs
new file mode 100644
index 000000000..8b5e04f27
--- /dev/null
+++ b/src/ImageSharp/Formats/Tiff/Utils/TiffUtilities.cs
@@ -0,0 +1,120 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Buffers.Binary;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.Intrinsics;
+using SixLabors.ImageSharp.PixelFormats;
+
+namespace SixLabors.ImageSharp.Formats.Tiff.Utils;
+
+/// <summary>
+/// Helper methods for TIFF decoding.
+/// </summary>
+internal static class TiffUtilities
+{
+    private const float Scale24Bit = 1f / 0xFFFFFF;
+    private static readonly Vector4 Scale24BitVector = Vector128.Create(Scale24Bit, Scale24Bit, Scale24Bit, 1f).AsVector4();
+
+    private const float Scale32Bit = 1f / 0xFFFFFFFF;
+    private static readonly Vector4 Scale32BitVector = Vector128.Create(Scale32Bit, Scale32Bit, Scale32Bit, 1f).AsVector4();
+
+    public static Rgba64 Rgba64Default { get; } = new(0, 0, 0, 0);
+
+    public static L16 L16Default { get; } = new(0);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static ushort ConvertToUShortBigEndian(ReadOnlySpan<byte> buffer) => BinaryPrimitives.ReadUInt16BigEndian(buffer);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static ushort ConvertToUShortLittleEndian(ReadOnlySpan<byte> buffer) => BinaryPrimitives.ReadUInt16LittleEndian(buffer);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static uint ConvertToUIntBigEndian(ReadOnlySpan<byte> buffer) => BinaryPrimitives.ReadUInt32BigEndian(buffer);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static uint ConvertToUIntLittleEndian(ReadOnlySpan<byte> buffer) => BinaryPrimitives.ReadUInt32LittleEndian(buffer);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel ColorFromRgba64Premultiplied<TPixel>(ushort r, ushort g, ushort b, ushort a)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        if (a == 0)
+        {
+            return TPixel.FromRgba64(default);
+        }
+
+        return TPixel.FromRgba64(new((ushort)(r / a), (ushort)(g / a), (ushort)(b / a), a));
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel ColorScaleTo24Bit<TPixel>(uint r, uint g, uint b)
+        where TPixel : unmanaged, IPixel<TPixel>
+        => TPixel.FromScaledVector4(new Vector4(r, g, b, 1f) * Scale24BitVector);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel ColorScaleTo24Bit<TPixel>(uint r, uint g, uint b, uint a)
+        where TPixel : unmanaged, IPixel<TPixel>
+        => TPixel.FromScaledVector4(new Vector4(r, g, b, a) * Scale24Bit);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel ColorScaleTo24BitPremultiplied<TPixel>(uint r, uint g, uint b, uint a)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        Vector4 colorVector = new Vector4(r, g, b, a) * Scale24Bit;
+        return UnPremultiply<TPixel>(ref colorVector);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel ColorScaleTo32Bit<TPixel>(uint r, uint g, uint b)
+        where TPixel : unmanaged, IPixel<TPixel>
+        => TPixel.FromScaledVector4(new Vector4(r, g, b, 1f) * Scale32BitVector);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel ColorScaleTo32Bit<TPixel>(uint r, uint g, uint b, uint a)
+        where TPixel : unmanaged, IPixel<TPixel>
+        => TPixel.FromScaledVector4(new Vector4(r, g, b, a) * Scale32Bit);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel ColorScaleTo32BitPremultiplied<TPixel>(uint r, uint g, uint b, uint a)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        Vector4 vector = new Vector4(r, g, b, a) * Scale32Bit;
+        return UnPremultiply<TPixel>(ref vector);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel ColorScaleTo24Bit<TPixel>(uint intensity)
+        where TPixel : unmanaged, IPixel<TPixel>
+        => TPixel.FromScaledVector4(new Vector4(intensity, intensity, intensity, 1f) * Scale24BitVector);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel ColorScaleTo32Bit<TPixel>(uint intensity)
+        where TPixel : unmanaged, IPixel<TPixel>
+        => TPixel.FromScaledVector4(new Vector4(intensity, intensity, intensity, 1f) * Scale32BitVector);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TPixel UnPremultiply<TPixel>(ref Vector4 vector)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        Numerics.UnPremultiply(ref vector);
+        return TPixel.FromScaledVector4(vector);
+    }
+
+    /// <summary>
+    /// Finds the padding needed to round 'valueToRoundUp' to the next integer multiple of subSampling value.
+    /// </summary>
+    /// <param name="valueToRoundUp">The width or height to round up.</param>
+    /// <param name="subSampling">The sub sampling.</param>
+    /// <returns>The padding.</returns>
+    public static int PaddingToNextInteger(int valueToRoundUp, int subSampling)
+    {
+        if (valueToRoundUp % subSampling == 0)
+        {
+            return 0;
+        }
+
+        return subSampling - (valueToRoundUp % subSampling);
+    }
+}
diff --git a/src/ImageSharp/Formats/Tiff/Utils/TiffUtils.cs b/src/ImageSharp/Formats/Tiff/Utils/TiffUtils.cs
deleted file mode 100644
index 7e0251af6..000000000
--- a/src/ImageSharp/Formats/Tiff/Utils/TiffUtils.cs
+++ /dev/null
@@ -1,176 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-
-using System.Buffers.Binary;
-using System.Numerics;
-using System.Runtime.CompilerServices;
-using SixLabors.ImageSharp.PixelFormats;
-
-namespace SixLabors.ImageSharp.Formats.Tiff.Utils;
-
-/// <summary>
-/// Helper methods for TIFF decoding.
-/// </summary>
-internal static class TiffUtils
-{
-    private const float Scale24Bit = 1.0f / 0xFFFFFF;
-
-    private const float Scale32Bit = 1.0f / 0xFFFFFFFF;
-
-    public static Rgba64 Rgba64Default { get; } = new(0, 0, 0, 0);
-
-    public static L16 L16Default { get; } = new(0);
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static ushort ConvertToUShortBigEndian(ReadOnlySpan<byte> buffer) => BinaryPrimitives.ReadUInt16BigEndian(buffer);
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static ushort ConvertToUShortLittleEndian(ReadOnlySpan<byte> buffer) => BinaryPrimitives.ReadUInt16LittleEndian(buffer);
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static uint ConvertToUIntBigEndian(ReadOnlySpan<byte> buffer) => BinaryPrimitives.ReadUInt32BigEndian(buffer);
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static uint ConvertToUIntLittleEndian(ReadOnlySpan<byte> buffer) => BinaryPrimitives.ReadUInt32LittleEndian(buffer);
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static TPixel ColorFromL8<TPixel>(L8 l8, byte intensity, TPixel color)
-        where TPixel : unmanaged, IPixel<TPixel>
-    {
-        l8.PackedValue = intensity;
-        color.FromL8(l8);
-        return color;
-    }
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static TPixel ColorFromRgb64<TPixel>(Rgba64 rgba, ulong r, ulong g, ulong b, TPixel color)
-        where TPixel : unmanaged, IPixel<TPixel>
-    {
-        rgba.PackedValue = r | (g << 16) | (b << 32) | (0xfffful << 48);
-        color.FromRgba64(rgba);
-        return color;
-    }
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static TPixel ColorFromRgba64<TPixel>(Rgba64 rgba, ulong r, ulong g, ulong b, ulong a, TPixel color)
-        where TPixel : unmanaged, IPixel<TPixel>
-    {
-        rgba.PackedValue = r | (g << 16) | (b << 32) | (a << 48);
-        color.FromRgba64(rgba);
-        return color;
-    }
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static TPixel ColorFromRgba64Premultiplied<TPixel>(Rgba64 rgba, ulong r, ulong g, ulong b, ulong a, TPixel color)
-        where TPixel : unmanaged, IPixel<TPixel>
-    {
-        rgba.PackedValue = r | (g << 16) | (b << 32) | (a << 48);
-        var vec = rgba.ToVector4();
-        return UnPremultiply(ref vec, color);
-    }
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static TPixel ColorScaleTo24Bit<TPixel>(ulong r, ulong g, ulong b, TPixel color)
-        where TPixel : unmanaged, IPixel<TPixel>
-    {
-        var colorVector = new Vector4(r * Scale24Bit, g * Scale24Bit, b * Scale24Bit, 1.0f);
-        color.FromScaledVector4(colorVector);
-        return color;
-    }
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static TPixel ColorScaleTo24Bit<TPixel>(ulong r, ulong g, ulong b, ulong a, TPixel color)
-        where TPixel : unmanaged, IPixel<TPixel>
-    {
-        Vector4 colorVector = new Vector4(r, g, b, a) * Scale24Bit;
-        color.FromScaledVector4(colorVector);
-        return color;
-    }
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static TPixel ColorScaleTo24BitPremultiplied<TPixel>(ulong r, ulong g, ulong b, ulong a, TPixel color)
-        where TPixel : unmanaged, IPixel<TPixel>
-    {
-        Vector4 colorVector = new Vector4(r, g, b, a) * Scale24Bit;
-        return UnPremultiply(ref colorVector, color);
-    }
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static TPixel ColorScaleTo32Bit<TPixel>(ulong r, ulong g, ulong b, TPixel color)
-        where TPixel : unmanaged, IPixel<TPixel>
-    {
-        var colorVector = new Vector4(r * Scale32Bit, g * Scale32Bit, b * Scale32Bit, 1.0f);
-        color.FromScaledVector4(colorVector);
-        return color;
-    }
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static TPixel ColorScaleTo32Bit<TPixel>(ulong r, ulong g, ulong b, ulong a, TPixel color)
-        where TPixel : unmanaged, IPixel<TPixel>
-    {
-        Vector4 colorVector = new Vector4(r, g, b, a) * Scale32Bit;
-        color.FromScaledVector4(colorVector);
-        return color;
-    }
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static TPixel ColorScaleTo32BitPremultiplied<TPixel>(ulong r, ulong g, ulong b, ulong a, TPixel color)
-        where TPixel : unmanaged, IPixel<TPixel>
-    {
-        Vector4 colorVector = new Vector4(r, g, b, a) * Scale32Bit;
-        return UnPremultiply(ref colorVector, color);
-    }
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static TPixel ColorFromL16<TPixel>(L16 l16, ushort intensity, TPixel color)
-        where TPixel : unmanaged, IPixel<TPixel>
-    {
-        l16.PackedValue = intensity;
-        color.FromL16(l16);
-        return color;
-    }
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static TPixel ColorScaleTo24Bit<TPixel>(ulong intensity, TPixel color)
-        where TPixel : unmanaged, IPixel<TPixel>
-    {
-        var colorVector = new Vector4(intensity * Scale24Bit, intensity * Scale24Bit, intensity * Scale24Bit, 1.0f);
-        color.FromScaledVector4(colorVector);
-        return color;
-    }
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static TPixel ColorScaleTo32Bit<TPixel>(ulong intensity, TPixel color)
-        where TPixel : unmanaged, IPixel<TPixel>
-    {
-        var colorVector = new Vector4(intensity * Scale32Bit, intensity * Scale32Bit, intensity * Scale32Bit, 1.0f);
-        color.FromScaledVector4(colorVector);
-        return color;
-    }
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static TPixel UnPremultiply<TPixel>(ref Vector4 vector, TPixel color)
-        where TPixel : unmanaged, IPixel<TPixel>
-    {
-        Numerics.UnPremultiply(ref vector);
-        color.FromScaledVector4(vector);
-
-        return color;
-    }
-
-    /// <summary>
-    /// Finds the padding needed to round 'valueToRoundUp' to the next integer multiple of subSampling value.
-    /// </summary>
-    /// <param name="valueToRoundUp">The width or height to round up.</param>
-    /// <param name="subSampling">The sub sampling.</param>
-    /// <returns>The padding.</returns>
-    public static int PaddingToNextInteger(int valueToRoundUp, int subSampling)
-    {
-        if (valueToRoundUp % subSampling == 0)
-        {
-            return 0;
-        }
-
-        return subSampling - (valueToRoundUp % subSampling);
-    }
-}
diff --git a/src/ImageSharp/Formats/Webp/BitWriter/BitWriterBase.cs b/src/ImageSharp/Formats/Webp/BitWriter/BitWriterBase.cs
index 9ffda0f51..927992686 100644
--- a/src/ImageSharp/Formats/Webp/BitWriter/BitWriterBase.cs
+++ b/src/ImageSharp/Formats/Webp/BitWriter/BitWriterBase.cs
@@ -1,11 +1,11 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using SixLabors.ImageSharp.Common.Helpers;
 using SixLabors.ImageSharp.Formats.Webp.Chunks;
 using SixLabors.ImageSharp.Metadata.Profiles.Exif;
 using SixLabors.ImageSharp.Metadata.Profiles.Icc;
 using SixLabors.ImageSharp.Metadata.Profiles.Xmp;
+using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Formats.Webp.BitWriter;
 
@@ -157,7 +157,7 @@ internal abstract class BitWriterBase
     /// <param name="loopCount">The number of times to loop the animation. If it is 0, this means infinitely.</param>
     public static void WriteAnimationParameter(Stream stream, Color background, ushort loopCount)
     {
-        WebpAnimationParameter chunk = new(background.ToBgra32().PackedValue, loopCount);
+        WebpAnimationParameter chunk = new(background.ToPixel<Bgra32>().PackedValue, loopCount);
         chunk.WriteTo(stream);
     }
 
diff --git a/src/ImageSharp/Formats/Webp/Chunks/WebpAnimationParameter.cs b/src/ImageSharp/Formats/Webp/Chunks/WebpAnimationParameter.cs
index 3855a293c..cff9f47af 100644
--- a/src/ImageSharp/Formats/Webp/Chunks/WebpAnimationParameter.cs
+++ b/src/ImageSharp/Formats/Webp/Chunks/WebpAnimationParameter.cs
@@ -2,7 +2,6 @@
 // Licensed under the Six Labors Split License.
 
 using System.Buffers.Binary;
-using SixLabors.ImageSharp.Common.Helpers;
 
 namespace SixLabors.ImageSharp.Formats.Webp.Chunks;
 
diff --git a/src/ImageSharp/Formats/Webp/Chunks/WebpFrameData.cs b/src/ImageSharp/Formats/Webp/Chunks/WebpFrameData.cs
index 5ed7aab1e..c8ff579a8 100644
--- a/src/ImageSharp/Formats/Webp/Chunks/WebpFrameData.cs
+++ b/src/ImageSharp/Formats/Webp/Chunks/WebpFrameData.cs
@@ -1,8 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using SixLabors.ImageSharp.Common.Helpers;
-
 namespace SixLabors.ImageSharp.Formats.Webp.Chunks;
 
 internal readonly struct WebpFrameData
diff --git a/src/ImageSharp/Formats/Webp/Chunks/WebpVp8X.cs b/src/ImageSharp/Formats/Webp/Chunks/WebpVp8X.cs
index 70d6870ce..f781d6114 100644
--- a/src/ImageSharp/Formats/Webp/Chunks/WebpVp8X.cs
+++ b/src/ImageSharp/Formats/Webp/Chunks/WebpVp8X.cs
@@ -1,8 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using SixLabors.ImageSharp.Common.Helpers;
-
 namespace SixLabors.ImageSharp.Formats.Webp.Chunks;
 
 internal readonly struct WebpVp8X
diff --git a/src/ImageSharp/Formats/Webp/Lossless/Vp8LEncoder.cs b/src/ImageSharp/Formats/Webp/Lossless/Vp8LEncoder.cs
index 518c09ff4..f15cb3eb5 100644
--- a/src/ImageSharp/Formats/Webp/Lossless/Vp8LEncoder.cs
+++ b/src/ImageSharp/Formats/Webp/Lossless/Vp8LEncoder.cs
@@ -6,7 +6,6 @@ using System.Buffers;
 using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
-using SixLabors.ImageSharp.Common.Helpers;
 using SixLabors.ImageSharp.Formats.Webp.BitWriter;
 using SixLabors.ImageSharp.Formats.Webp.Chunks;
 using SixLabors.ImageSharp.Memory;
diff --git a/src/ImageSharp/Formats/Webp/Lossy/Vp8Encoder.cs b/src/ImageSharp/Formats/Webp/Lossy/Vp8Encoder.cs
index 2b74c300a..6e9e4f9cd 100644
--- a/src/ImageSharp/Formats/Webp/Lossy/Vp8Encoder.cs
+++ b/src/ImageSharp/Formats/Webp/Lossy/Vp8Encoder.cs
@@ -4,7 +4,6 @@
 
 using System.Buffers;
 using System.Runtime.CompilerServices;
-using SixLabors.ImageSharp.Common.Helpers;
 using SixLabors.ImageSharp.Formats.Webp.BitWriter;
 using SixLabors.ImageSharp.Formats.Webp.Chunks;
 using SixLabors.ImageSharp.Memory;
diff --git a/src/ImageSharp/Formats/Webp/Lossy/WebpLossyDecoder.cs b/src/ImageSharp/Formats/Webp/Lossy/WebpLossyDecoder.cs
index 3eb03b172..65d5b65e8 100644
--- a/src/ImageSharp/Formats/Webp/Lossy/WebpLossyDecoder.cs
+++ b/src/ImageSharp/Formats/Webp/Lossy/WebpLossyDecoder.cs
@@ -140,7 +140,6 @@ internal sealed class WebpLossyDecoder
     private static void DecodePixelValues<TPixel>(int width, int height, Span<byte> pixelData, Buffer2D<TPixel> decodedPixels, IMemoryOwner<byte> alpha)
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        TPixel color = default;
         Span<byte> alphaSpan = alpha.Memory.Span;
         Span<Bgr24> pixelsBgr = MemoryMarshal.Cast<byte, Bgr24>(pixelData);
         for (int y = 0; y < height; y++)
@@ -151,8 +150,7 @@ internal sealed class WebpLossyDecoder
             {
                 int offset = yMulWidth + x;
                 Bgr24 bgr = pixelsBgr[offset];
-                color.FromBgra32(new Bgra32(bgr.R, bgr.G, bgr.B, alphaSpan[offset]));
-                decodedPixelRow[x] = color;
+                decodedPixelRow[x] = TPixel.FromBgra32(new(bgr.R, bgr.G, bgr.B, alphaSpan[offset]));
             }
         }
     }
diff --git a/src/ImageSharp/Common/Helpers/RiffHelper.cs b/src/ImageSharp/Formats/Webp/RiffHelper.cs
similarity index 98%
rename from src/ImageSharp/Common/Helpers/RiffHelper.cs
rename to src/ImageSharp/Formats/Webp/RiffHelper.cs
index 8f06e5886..d3862ea8b 100644
--- a/src/ImageSharp/Common/Helpers/RiffHelper.cs
+++ b/src/ImageSharp/Formats/Webp/RiffHelper.cs
@@ -4,7 +4,7 @@
 using System.Buffers.Binary;
 using System.Text;
 
-namespace SixLabors.ImageSharp.Common.Helpers;
+namespace SixLabors.ImageSharp.Formats.Webp;
 
 internal static class RiffHelper
 {
diff --git a/src/ImageSharp/Formats/Webp/WebpAnimationDecoder.cs b/src/ImageSharp/Formats/Webp/WebpAnimationDecoder.cs
index 65f1a4da4..70372fe98 100644
--- a/src/ImageSharp/Formats/Webp/WebpAnimationDecoder.cs
+++ b/src/ImageSharp/Formats/Webp/WebpAnimationDecoder.cs
@@ -102,7 +102,7 @@ internal class WebpAnimationDecoder : IDisposable
             {
                 case WebpChunkType.FrameData:
                     Color backgroundColor = this.backgroundColorHandling == BackgroundColorHandling.Ignore
-                        ? new Color(new Bgra32(0, 0, 0, 0))
+                        ? Color.FromPixel(new Bgra32(0, 0, 0, 0))
                         : features.AnimationBackgroundColor!.Value;
                     uint dataSize = this.ReadFrame(stream, ref image, ref previousFrame, width, height, backgroundColor);
                     remainingBytes -= (int)dataSize;
diff --git a/src/ImageSharp/Formats/Webp/WebpDecoderCore.cs b/src/ImageSharp/Formats/Webp/WebpDecoderCore.cs
index 69a0afcd9..2991f355f 100644
--- a/src/ImageSharp/Formats/Webp/WebpDecoderCore.cs
+++ b/src/ImageSharp/Formats/Webp/WebpDecoderCore.cs
@@ -438,7 +438,7 @@ internal sealed class WebpDecoderCore : IImageDecoderInternals, IDisposable
         byte green = (byte)stream.ReadByte();
         byte red = (byte)stream.ReadByte();
         byte alpha = (byte)stream.ReadByte();
-        features.AnimationBackgroundColor = new Color(new Rgba32(red, green, blue, alpha));
+        features.AnimationBackgroundColor = Color.FromPixel(new Rgba32(red, green, blue, alpha));
         int bytesRead = stream.Read(buffer, 0, 2);
         if (bytesRead != 2)
         {
diff --git a/src/ImageSharp/Formats/Webp/WebpFrameMetadata.cs b/src/ImageSharp/Formats/Webp/WebpFrameMetadata.cs
index 422ad6bc7..cd1b5d590 100644
--- a/src/ImageSharp/Formats/Webp/WebpFrameMetadata.cs
+++ b/src/ImageSharp/Formats/Webp/WebpFrameMetadata.cs
@@ -48,7 +48,7 @@ public class WebpFrameMetadata : IDeepCloneable
     internal static WebpFrameMetadata FromAnimatedMetadata(AnimatedImageFrameMetadata metadata)
         => new()
         {
-            FrameDelay = (uint)metadata.Duration.Milliseconds,
+            FrameDelay = (uint)metadata.Duration.TotalMilliseconds,
             BlendMethod = metadata.BlendMode == FrameBlendMode.Source ? WebpBlendMethod.Source : WebpBlendMethod.Over,
             DisposalMethod = metadata.DisposalMode == FrameDisposalMode.RestoreToBackground ? WebpDisposalMethod.RestoreToBackground : WebpDisposalMethod.DoNotDispose
         };
diff --git a/src/ImageSharp/ImageInfo.cs b/src/ImageSharp/ImageInfo.cs
index 00319e9b5..c0d1f27ca 100644
--- a/src/ImageSharp/ImageInfo.cs
+++ b/src/ImageSharp/ImageInfo.cs
@@ -1,8 +1,8 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.Metadata;
+using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp;
 
diff --git a/src/ImageSharp/Image{TPixel}.cs b/src/ImageSharp/Image{TPixel}.cs
index c24014e69..e12631cbd 100644
--- a/src/ImageSharp/Image{TPixel}.cs
+++ b/src/ImageSharp/Image{TPixel}.cs
@@ -4,7 +4,6 @@
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using SixLabors.ImageSharp.Advanced;
-using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.Metadata;
 using SixLabors.ImageSharp.PixelFormats;
@@ -78,7 +77,7 @@ public sealed class Image<TPixel> : Image
     /// <param name="height">The height of the image in pixels.</param>
     /// <param name="metadata">The images metadata.</param>
     internal Image(Configuration configuration, int width, int height, ImageMetadata? metadata)
-        : base(configuration, PixelTypeInfo.Create<TPixel>(), metadata ?? new(), width, height)
+        : base(configuration, TPixel.GetPixelTypeInfo(), metadata ?? new(), width, height)
         => this.frames = new ImageFrameCollection<TPixel>(this, width, height, default(TPixel));
 
     /// <summary>
@@ -111,7 +110,7 @@ public sealed class Image<TPixel> : Image
         int width,
         int height,
         ImageMetadata metadata)
-        : base(configuration, PixelTypeInfo.Create<TPixel>(), metadata, width, height)
+        : base(configuration, TPixel.GetPixelTypeInfo(), metadata, width, height)
         => this.frames = new ImageFrameCollection<TPixel>(this, width, height, memoryGroup);
 
     /// <summary>
@@ -129,7 +128,7 @@ public sealed class Image<TPixel> : Image
         int height,
         TPixel backgroundColor,
         ImageMetadata? metadata)
-        : base(configuration, PixelTypeInfo.Create<TPixel>(), metadata ?? new(), width, height)
+        : base(configuration, TPixel.GetPixelTypeInfo(), metadata ?? new(), width, height)
         => this.frames = new ImageFrameCollection<TPixel>(this, width, height, backgroundColor);
 
     /// <summary>
@@ -140,7 +139,7 @@ public sealed class Image<TPixel> : Image
     /// <param name="metadata">The images metadata.</param>
     /// <param name="frames">The frames that will be owned by this image instance.</param>
     internal Image(Configuration configuration, ImageMetadata metadata, IEnumerable<ImageFrame<TPixel>> frames)
-        : base(configuration, PixelTypeInfo.Create<TPixel>(), metadata, ValidateFramesAndGetSize(frames))
+        : base(configuration, TPixel.GetPixelTypeInfo(), metadata, ValidateFramesAndGetSize(frames))
         => this.frames = new ImageFrameCollection<TPixel>(this, frames);
 
     /// <inheritdoc />
diff --git a/src/ImageSharp/PixelFormats/IPackedVector{TPacked}.cs b/src/ImageSharp/PixelFormats/IPackedVector{TPacked}.cs
index b74c0ff44..18a8df348 100644
--- a/src/ImageSharp/PixelFormats/IPackedVector{TPacked}.cs
+++ b/src/ImageSharp/PixelFormats/IPackedVector{TPacked}.cs
@@ -1,4 +1,4 @@
-// Copyright (c) Six Labors.
+// Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
 namespace SixLabors.ImageSharp.PixelFormats;
diff --git a/src/ImageSharp/PixelFormats/IPixel.cs b/src/ImageSharp/PixelFormats/IPixel.cs
index 099444466..adf386614 100644
--- a/src/ImageSharp/PixelFormats/IPixel.cs
+++ b/src/ImageSharp/PixelFormats/IPixel.cs
@@ -14,127 +14,150 @@ namespace SixLabors.ImageSharp.PixelFormats;
 public interface IPixel<TSelf> : IPixel, IEquatable<TSelf>
     where TSelf : unmanaged, IPixel<TSelf>
 {
+#pragma warning disable CA1000 // Do not declare static members on generic types
     /// <summary>
     /// Creates a <see cref="PixelOperations{TPixel}"/> instance for this pixel type.
     /// This method is not intended to be consumed directly. Use <see cref="PixelOperations{TPixel}.Instance"/> instead.
     /// </summary>
     /// <returns>The <see cref="PixelOperations{TPixel}"/> instance.</returns>
-    PixelOperations<TSelf> CreatePixelOperations();
-}
+    static abstract PixelOperations<TSelf> CreatePixelOperations();
 
-/// <summary>
-/// A base interface for all pixels, defining the mandatory operations to be implemented by a pixel type.
-/// </summary>
-public interface IPixel
-{
     /// <summary>
-    /// Initializes the pixel instance from a generic ("scaled") <see cref="Vector4"/>.
+    /// Initializes the pixel instance from a generic scaled <see cref="Vector4"/>.
     /// </summary>
-    /// <param name="vector">The vector to load the pixel from.</param>
-    void FromScaledVector4(Vector4 vector);
-
-    /// <summary>
-    /// Expands the pixel into a generic ("scaled") <see cref="Vector4"/> representation
-    /// with values scaled and clamped between <value>0</value> and <value>1</value>.
-    /// The vector components are typically expanded in least to greatest significance order.
-    /// </summary>
-    /// <returns>The <see cref="Vector4"/>.</returns>
-    Vector4 ToScaledVector4();
+    /// <param name="source">The vector to load the pixel from.</param>
+    /// <returns>The <typeparamref name="TSelf"/>.</returns>
+    static abstract TSelf FromScaledVector4(Vector4 source);
 
     /// <summary>
     /// Initializes the pixel instance from a <see cref="Vector4"/> which is specific to the current pixel type.
     /// </summary>
-    /// <param name="vector">The vector to load the pixel from.</param>
-    void FromVector4(Vector4 vector);
+    /// <param name="source">The vector to load the pixel from.</param>
+    /// <returns>The <typeparamref name="TSelf"/>.</returns>
+    static abstract TSelf FromVector4(Vector4 source);
 
     /// <summary>
-    /// Expands the pixel into a <see cref="Vector4"/> which is specific to the current pixel type.
-    /// The vector components are typically expanded in least to greatest significance order.
+    /// Initializes the pixel instance from an <see cref="Abgr32"/> value.
     /// </summary>
-    /// <returns>The <see cref="Vector4"/>.</returns>
-    Vector4 ToVector4();
+    /// <param name="source">The <see cref="Abgr32"/> value.</param>
+    /// <returns>The <typeparamref name="TSelf"/>.</returns>
+    static abstract TSelf FromAbgr32(Abgr32 source);
 
     /// <summary>
     /// Initializes the pixel instance from an <see cref="Argb32"/> value.
     /// </summary>
     /// <param name="source">The <see cref="Argb32"/> value.</param>
-    void FromArgb32(Argb32 source);
+    /// <returns>The <typeparamref name="TSelf"/>.</returns>
+    static abstract TSelf FromArgb32(Argb32 source);
 
     /// <summary>
     /// Initializes the pixel instance from an <see cref="Bgra5551"/> value.
     /// </summary>
     /// <param name="source">The <see cref="Bgra5551"/> value.</param>
-    void FromBgra5551(Bgra5551 source);
+    /// <returns>The <typeparamref name="TSelf"/>.</returns>
+    static abstract TSelf FromBgra5551(Bgra5551 source);
 
     /// <summary>
     /// Initializes the pixel instance from an <see cref="Bgr24"/> value.
     /// </summary>
     /// <param name="source">The <see cref="Bgr24"/> value.</param>
-    void FromBgr24(Bgr24 source);
+    /// <returns>The <typeparamref name="TSelf"/>.</returns>
+    static abstract TSelf FromBgr24(Bgr24 source);
 
     /// <summary>
     /// Initializes the pixel instance from an <see cref="Bgra32"/> value.
     /// </summary>
     /// <param name="source">The <see cref="Bgra32"/> value.</param>
-    void FromBgra32(Bgra32 source);
-
-    /// <summary>
-    /// Initializes the pixel instance from an <see cref="Abgr32"/> value.
-    /// </summary>
-    /// <param name="source">The <see cref="Abgr32"/> value.</param>
-    void FromAbgr32(Abgr32 source);
+    /// <returns>The <typeparamref name="TSelf"/>.</returns>
+    static abstract TSelf FromBgra32(Bgra32 source);
 
     /// <summary>
     /// Initializes the pixel instance from an <see cref="L8"/> value.
     /// </summary>
     /// <param name="source">The <see cref="L8"/> value.</param>
-    void FromL8(L8 source);
+    /// <returns>The <typeparamref name="TSelf"/>.</returns>
+    static abstract TSelf FromL8(L8 source);
 
     /// <summary>
     /// Initializes the pixel instance from an <see cref="L16"/> value.
     /// </summary>
     /// <param name="source">The <see cref="L16"/> value.</param>
-    void FromL16(L16 source);
+    /// <returns>The <typeparamref name="TSelf"/>.</returns>
+    static abstract TSelf FromL16(L16 source);
 
     /// <summary>
     /// Initializes the pixel instance from an <see cref="La16"/> value.
     /// </summary>
     /// <param name="source">The <see cref="La16"/> value.</param>
-    void FromLa16(La16 source);
+    /// <returns>The <typeparamref name="TSelf"/>.</returns>
+    static abstract TSelf FromLa16(La16 source);
 
     /// <summary>
     /// Initializes the pixel instance from an <see cref="La32"/> value.
     /// </summary>
     /// <param name="source">The <see cref="La32"/> value.</param>
-    void FromLa32(La32 source);
+    /// <returns>The <typeparamref name="TSelf"/>.</returns>
+    static abstract TSelf FromLa32(La32 source);
 
     /// <summary>
     /// Initializes the pixel instance from an <see cref="Rgb24"/> value.
     /// </summary>
     /// <param name="source">The <see cref="Rgb24"/> value.</param>
-    void FromRgb24(Rgb24 source);
+    /// <returns>The <typeparamref name="TSelf"/>.</returns>
+    static abstract TSelf FromRgb24(Rgb24 source);
 
     /// <summary>
     /// Initializes the pixel instance from an <see cref="Rgba32"/> value.
     /// </summary>
     /// <param name="source">The <see cref="Rgba32"/> value.</param>
-    void FromRgba32(Rgba32 source);
-
-    /// <summary>
-    /// Convert the pixel instance into <see cref="Rgba32"/> representation.
-    /// </summary>
-    /// <param name="dest">The reference to the destination <see cref="Rgba32"/> pixel</param>
-    void ToRgba32(ref Rgba32 dest);
+    /// <returns>The <typeparamref name="TSelf"/>.</returns>
+    static abstract TSelf FromRgba32(Rgba32 source);
 
     /// <summary>
     /// Initializes the pixel instance from an <see cref="Rgb48"/> value.
     /// </summary>
     /// <param name="source">The <see cref="Rgb48"/> value.</param>
-    void FromRgb48(Rgb48 source);
+    /// <returns>The <typeparamref name="TSelf"/>.</returns>
+    static abstract TSelf FromRgb48(Rgb48 source);
 
     /// <summary>
     /// Initializes the pixel instance from an <see cref="Rgba64"/> value.
     /// </summary>
     /// <param name="source">The <see cref="Rgba64"/> value.</param>
-    void FromRgba64(Rgba64 source);
+    /// <returns>The <typeparamref name="TSelf"/>.</returns>
+    static abstract TSelf FromRgba64(Rgba64 source);
+#pragma warning restore CA1000 // Do not declare static members on generic types
+}
+
+/// <summary>
+/// A base interface for all pixels, defining the mandatory operations to be implemented by a pixel type.
+/// </summary>
+public interface IPixel
+{
+    /// <summary>
+    /// Gets the pixel type information.
+    /// </summary>
+    /// <returns>The <see cref="PixelTypeInfo"/>.</returns>
+    static abstract PixelTypeInfo GetPixelTypeInfo();
+
+    /// <summary>
+    /// Convert the pixel instance into <see cref="Rgba32"/> representation.
+    /// </summary>
+    /// <returns>The <see cref="Rgba32"/></returns>
+    Rgba32 ToRgba32();
+
+    /// <summary>
+    /// Expands the pixel into a generic ("scaled") <see cref="Vector4"/> representation
+    /// with values scaled and clamped between <value>0</value> and <value>1</value>.
+    /// The vector components are typically expanded in least to greatest significance order.
+    /// </summary>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    Vector4 ToScaledVector4();
+
+    /// <summary>
+    /// Expands the pixel into a <see cref="Vector4"/> which is specific to the current pixel type.
+    /// The vector components are typically expanded in least to greatest significance order.
+    /// </summary>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    Vector4 ToVector4();
 }
diff --git a/src/ImageSharp/PixelFormats/PixelBlenders/DefaultPixelBlenders.Generated.cs b/src/ImageSharp/PixelFormats/PixelBlenders/DefaultPixelBlenders.Generated.cs
index 079230676..f62d3c676 100644
--- a/src/ImageSharp/PixelFormats/PixelBlenders/DefaultPixelBlenders.Generated.cs
+++ b/src/ImageSharp/PixelFormats/PixelBlenders/DefaultPixelBlenders.Generated.cs
@@ -38,9 +38,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.NormalSrc(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.NormalSrc(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -143,9 +141,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.MultiplySrc(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.MultiplySrc(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -248,9 +244,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.AddSrc(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.AddSrc(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -353,9 +347,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.SubtractSrc(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.SubtractSrc(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -458,9 +450,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.ScreenSrc(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.ScreenSrc(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -563,9 +553,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.DarkenSrc(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.DarkenSrc(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -668,9 +656,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.LightenSrc(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.LightenSrc(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -773,9 +759,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.OverlaySrc(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.OverlaySrc(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -878,9 +862,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.HardLightSrc(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.HardLightSrc(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -983,9 +965,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.NormalSrcAtop(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.NormalSrcAtop(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -1088,9 +1068,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.MultiplySrcAtop(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.MultiplySrcAtop(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -1193,9 +1171,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.AddSrcAtop(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.AddSrcAtop(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -1298,9 +1274,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.SubtractSrcAtop(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.SubtractSrcAtop(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -1403,9 +1377,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.ScreenSrcAtop(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.ScreenSrcAtop(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -1508,9 +1480,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.DarkenSrcAtop(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.DarkenSrcAtop(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -1613,9 +1583,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.LightenSrcAtop(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.LightenSrcAtop(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -1718,9 +1686,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.OverlaySrcAtop(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.OverlaySrcAtop(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -1823,9 +1789,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.HardLightSrcAtop(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.HardLightSrcAtop(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -1928,9 +1892,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.NormalSrcOver(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.NormalSrcOver(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -2033,9 +1995,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.MultiplySrcOver(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.MultiplySrcOver(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -2138,9 +2098,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.AddSrcOver(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.AddSrcOver(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -2243,9 +2201,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.SubtractSrcOver(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.SubtractSrcOver(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -2348,9 +2304,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.ScreenSrcOver(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.ScreenSrcOver(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -2453,9 +2407,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.DarkenSrcOver(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.DarkenSrcOver(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -2558,9 +2510,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.LightenSrcOver(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.LightenSrcOver(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -2663,9 +2613,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.OverlaySrcOver(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.OverlaySrcOver(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -2768,9 +2716,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.HardLightSrcOver(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.HardLightSrcOver(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -2873,9 +2819,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.NormalSrcIn(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.NormalSrcIn(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -2978,9 +2922,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.MultiplySrcIn(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.MultiplySrcIn(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -3083,9 +3025,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.AddSrcIn(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.AddSrcIn(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -3188,9 +3128,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.SubtractSrcIn(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.SubtractSrcIn(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -3293,9 +3231,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.ScreenSrcIn(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.ScreenSrcIn(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -3398,9 +3334,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.DarkenSrcIn(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.DarkenSrcIn(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -3503,9 +3437,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.LightenSrcIn(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.LightenSrcIn(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -3608,9 +3540,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.OverlaySrcIn(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.OverlaySrcIn(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -3713,9 +3643,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.HardLightSrcIn(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.HardLightSrcIn(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -3818,9 +3746,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.NormalSrcOut(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.NormalSrcOut(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -3923,9 +3849,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.MultiplySrcOut(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.MultiplySrcOut(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -4028,9 +3952,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.AddSrcOut(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.AddSrcOut(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -4133,9 +4055,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.SubtractSrcOut(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.SubtractSrcOut(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -4238,9 +4158,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.ScreenSrcOut(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.ScreenSrcOut(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -4343,9 +4261,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.DarkenSrcOut(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.DarkenSrcOut(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -4448,9 +4364,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.LightenSrcOut(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.LightenSrcOut(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -4553,9 +4467,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.OverlaySrcOut(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.OverlaySrcOut(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -4658,9 +4570,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.HardLightSrcOut(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.HardLightSrcOut(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -4763,9 +4673,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.NormalDest(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.NormalDest(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -4868,9 +4776,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.MultiplyDest(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.MultiplyDest(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -4973,9 +4879,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.AddDest(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.AddDest(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -5078,9 +4982,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.SubtractDest(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.SubtractDest(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -5183,9 +5085,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.ScreenDest(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.ScreenDest(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -5288,9 +5188,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.DarkenDest(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.DarkenDest(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -5393,9 +5291,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.LightenDest(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.LightenDest(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -5498,9 +5394,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.OverlayDest(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.OverlayDest(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -5603,9 +5497,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.HardLightDest(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.HardLightDest(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -5708,9 +5600,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.NormalDestAtop(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.NormalDestAtop(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -5813,9 +5703,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.MultiplyDestAtop(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.MultiplyDestAtop(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -5918,9 +5806,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.AddDestAtop(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.AddDestAtop(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -6023,9 +5909,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.SubtractDestAtop(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.SubtractDestAtop(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -6128,9 +6012,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.ScreenDestAtop(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.ScreenDestAtop(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -6233,9 +6115,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.DarkenDestAtop(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.DarkenDestAtop(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -6338,9 +6218,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.LightenDestAtop(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.LightenDestAtop(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -6443,9 +6321,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.OverlayDestAtop(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.OverlayDestAtop(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -6548,9 +6424,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.HardLightDestAtop(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.HardLightDestAtop(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -6653,9 +6527,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.NormalDestOver(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.NormalDestOver(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -6758,9 +6630,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.MultiplyDestOver(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.MultiplyDestOver(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -6863,9 +6733,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.AddDestOver(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.AddDestOver(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -6968,9 +6836,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.SubtractDestOver(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.SubtractDestOver(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -7073,9 +6939,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.ScreenDestOver(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.ScreenDestOver(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -7178,9 +7042,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.DarkenDestOver(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.DarkenDestOver(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -7283,9 +7145,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.LightenDestOver(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.LightenDestOver(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -7388,9 +7248,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.OverlayDestOver(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.OverlayDestOver(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -7493,9 +7351,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.HardLightDestOver(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.HardLightDestOver(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -7598,9 +7454,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.NormalDestIn(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.NormalDestIn(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -7703,9 +7557,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.MultiplyDestIn(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.MultiplyDestIn(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -7808,9 +7660,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.AddDestIn(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.AddDestIn(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -7913,9 +7763,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.SubtractDestIn(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.SubtractDestIn(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -8018,9 +7866,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.ScreenDestIn(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.ScreenDestIn(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -8123,9 +7969,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.DarkenDestIn(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.DarkenDestIn(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -8228,9 +8072,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.LightenDestIn(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.LightenDestIn(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -8333,9 +8175,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.OverlayDestIn(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.OverlayDestIn(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -8438,9 +8278,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.HardLightDestIn(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.HardLightDestIn(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -8543,9 +8381,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.NormalDestOut(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.NormalDestOut(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -8648,9 +8484,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.MultiplyDestOut(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.MultiplyDestOut(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -8753,9 +8587,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.AddDestOut(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.AddDestOut(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -8858,9 +8690,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.SubtractDestOut(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.SubtractDestOut(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -8963,9 +8793,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.ScreenDestOut(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.ScreenDestOut(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -9068,9 +8896,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.DarkenDestOut(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.DarkenDestOut(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -9173,9 +8999,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.LightenDestOut(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.LightenDestOut(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -9278,9 +9102,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.OverlayDestOut(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.OverlayDestOut(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -9383,9 +9205,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.HardLightDestOut(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.HardLightDestOut(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -9488,9 +9308,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.NormalClear(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.NormalClear(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -9593,9 +9411,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.MultiplyClear(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.MultiplyClear(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -9698,9 +9514,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.AddClear(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.AddClear(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -9803,9 +9617,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.SubtractClear(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.SubtractClear(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -9908,9 +9720,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.ScreenClear(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.ScreenClear(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -10013,9 +9823,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.DarkenClear(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.DarkenClear(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -10118,9 +9926,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.LightenClear(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.LightenClear(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -10223,9 +10029,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.OverlayClear(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.OverlayClear(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -10328,9 +10132,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.HardLightClear(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.HardLightClear(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -10433,9 +10235,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.NormalXor(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.NormalXor(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -10538,9 +10338,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.MultiplyXor(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.MultiplyXor(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -10643,9 +10441,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.AddXor(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.AddXor(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -10748,9 +10544,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.SubtractXor(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.SubtractXor(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -10853,9 +10647,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.ScreenXor(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.ScreenXor(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -10958,9 +10750,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.DarkenXor(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.DarkenXor(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -11063,9 +10853,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.LightenXor(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.LightenXor(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -11168,9 +10956,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.OverlayXor(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.OverlayXor(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
@@ -11273,9 +11059,7 @@ internal static class DefaultPixelBlenders<TPixel>
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.HardLightXor(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.HardLightXor(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
diff --git a/src/ImageSharp/PixelFormats/PixelBlenders/DefaultPixelBlenders.Generated.tt b/src/ImageSharp/PixelFormats/PixelBlenders/DefaultPixelBlenders.Generated.tt
index da6208eaa..5b71bb0a6 100644
--- a/src/ImageSharp/PixelFormats/PixelBlenders/DefaultPixelBlenders.Generated.tt
+++ b/src/ImageSharp/PixelFormats/PixelBlenders/DefaultPixelBlenders.Generated.tt
@@ -81,9 +81,7 @@ var blenders = new []{
         /// <inheritdoc />
         public override TPixel Blend(TPixel background, TPixel source, float amount)
         {
-            TPixel dest = default;
-            dest.FromScaledVector4(PorterDuffFunctions.<#=blender_composer#>(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-            return dest;
+            return TPixel.FromScaledVector4(PorterDuffFunctions.<#=blender_composer#>(background.ToScaledVector4(), source.ToScaledVector4(), Numerics.Clamp(amount, 0, 1)));
         }
 
         /// <inheritdoc />
diff --git a/src/ImageSharp/PixelFormats/PixelBlenders/PorterDuffFunctions.Generated.cs b/src/ImageSharp/PixelFormats/PixelBlenders/PorterDuffFunctions.Generated.cs
index e7cf3b292..255bafc79 100644
--- a/src/ImageSharp/PixelFormats/PixelBlenders/PorterDuffFunctions.Generated.cs
+++ b/src/ImageSharp/PixelFormats/PixelBlenders/PorterDuffFunctions.Generated.cs
@@ -355,9 +355,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(NormalSrc(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(NormalSrc(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -373,9 +371,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(NormalSrcAtop(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(NormalSrcAtop(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -391,9 +387,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(NormalSrcOver(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(NormalSrcOver(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -409,9 +403,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(NormalSrcIn(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(NormalSrcIn(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -427,9 +419,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(NormalSrcOut(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(NormalSrcOut(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -445,9 +435,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(NormalDest(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(NormalDest(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -463,9 +451,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(NormalDestAtop(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(NormalDestAtop(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -481,9 +467,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(NormalDestOver(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(NormalDestOver(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -499,9 +483,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(NormalDestIn(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(NormalDestIn(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -517,9 +499,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(NormalDestOut(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(NormalDestOut(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -535,9 +515,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(NormalClear(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(NormalClear(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -553,9 +531,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(NormalXor(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(NormalXor(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -900,9 +876,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(MultiplySrc(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(MultiplySrc(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -918,9 +892,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(MultiplySrcAtop(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(MultiplySrcAtop(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -936,9 +908,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(MultiplySrcOver(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(MultiplySrcOver(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -954,9 +924,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(MultiplySrcIn(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(MultiplySrcIn(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -972,9 +940,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(MultiplySrcOut(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(MultiplySrcOut(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -990,9 +956,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(MultiplyDest(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(MultiplyDest(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -1008,9 +972,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(MultiplyDestAtop(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(MultiplyDestAtop(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -1026,9 +988,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(MultiplyDestOver(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(MultiplyDestOver(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -1044,9 +1004,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(MultiplyDestIn(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(MultiplyDestIn(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -1062,9 +1020,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(MultiplyDestOut(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(MultiplyDestOut(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -1080,9 +1036,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(MultiplyClear(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(MultiplyClear(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -1098,9 +1052,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(MultiplyXor(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(MultiplyXor(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -1445,9 +1397,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(AddSrc(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(AddSrc(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -1463,9 +1413,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(AddSrcAtop(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(AddSrcAtop(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -1481,9 +1429,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(AddSrcOver(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(AddSrcOver(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -1499,9 +1445,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(AddSrcIn(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(AddSrcIn(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -1517,9 +1461,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(AddSrcOut(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(AddSrcOut(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -1535,9 +1477,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(AddDest(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(AddDest(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -1553,9 +1493,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(AddDestAtop(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(AddDestAtop(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -1571,9 +1509,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(AddDestOver(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(AddDestOver(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -1589,9 +1525,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(AddDestIn(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(AddDestIn(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -1607,9 +1541,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(AddDestOut(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(AddDestOut(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -1625,9 +1557,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(AddClear(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(AddClear(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -1643,9 +1573,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(AddXor(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(AddXor(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -1990,9 +1918,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(SubtractSrc(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(SubtractSrc(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -2008,9 +1934,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(SubtractSrcAtop(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(SubtractSrcAtop(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -2026,9 +1950,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(SubtractSrcOver(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(SubtractSrcOver(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -2044,9 +1966,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(SubtractSrcIn(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(SubtractSrcIn(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -2062,9 +1982,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(SubtractSrcOut(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(SubtractSrcOut(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -2080,9 +1998,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(SubtractDest(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(SubtractDest(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -2098,9 +2014,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(SubtractDestAtop(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(SubtractDestAtop(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -2116,9 +2030,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(SubtractDestOver(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(SubtractDestOver(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -2134,9 +2046,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(SubtractDestIn(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(SubtractDestIn(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -2152,9 +2062,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(SubtractDestOut(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(SubtractDestOut(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -2170,9 +2078,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(SubtractClear(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(SubtractClear(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -2188,9 +2094,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(SubtractXor(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(SubtractXor(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -2535,9 +2439,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(ScreenSrc(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(ScreenSrc(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -2553,9 +2455,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(ScreenSrcAtop(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(ScreenSrcAtop(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -2571,9 +2471,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(ScreenSrcOver(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(ScreenSrcOver(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -2589,9 +2487,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(ScreenSrcIn(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(ScreenSrcIn(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -2607,9 +2503,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(ScreenSrcOut(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(ScreenSrcOut(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -2625,9 +2519,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(ScreenDest(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(ScreenDest(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -2643,9 +2535,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(ScreenDestAtop(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(ScreenDestAtop(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -2661,9 +2551,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(ScreenDestOver(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(ScreenDestOver(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -2679,9 +2567,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(ScreenDestIn(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(ScreenDestIn(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -2697,9 +2583,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(ScreenDestOut(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(ScreenDestOut(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -2715,9 +2599,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(ScreenClear(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(ScreenClear(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -2733,9 +2615,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(ScreenXor(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(ScreenXor(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -3080,9 +2960,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(DarkenSrc(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(DarkenSrc(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -3098,9 +2976,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(DarkenSrcAtop(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(DarkenSrcAtop(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -3116,9 +2992,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(DarkenSrcOver(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(DarkenSrcOver(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -3134,9 +3008,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(DarkenSrcIn(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(DarkenSrcIn(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -3152,9 +3024,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(DarkenSrcOut(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(DarkenSrcOut(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -3170,9 +3040,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(DarkenDest(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(DarkenDest(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -3188,9 +3056,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(DarkenDestAtop(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(DarkenDestAtop(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -3206,9 +3072,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(DarkenDestOver(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(DarkenDestOver(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -3224,9 +3088,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(DarkenDestIn(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(DarkenDestIn(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -3242,9 +3104,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(DarkenDestOut(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(DarkenDestOut(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -3260,9 +3120,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(DarkenClear(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(DarkenClear(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -3278,9 +3136,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(DarkenXor(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(DarkenXor(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -3625,9 +3481,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(LightenSrc(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(LightenSrc(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -3643,9 +3497,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(LightenSrcAtop(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(LightenSrcAtop(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -3661,9 +3513,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(LightenSrcOver(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(LightenSrcOver(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -3679,9 +3529,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(LightenSrcIn(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(LightenSrcIn(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -3697,9 +3545,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(LightenSrcOut(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(LightenSrcOut(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -3715,9 +3561,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(LightenDest(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(LightenDest(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -3733,9 +3577,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(LightenDestAtop(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(LightenDestAtop(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -3751,9 +3593,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(LightenDestOver(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(LightenDestOver(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -3769,9 +3609,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(LightenDestIn(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(LightenDestIn(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -3787,9 +3625,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(LightenDestOut(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(LightenDestOut(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -3805,9 +3641,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(LightenClear(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(LightenClear(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -3823,9 +3657,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(LightenXor(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(LightenXor(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -4170,9 +4002,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(OverlaySrc(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(OverlaySrc(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -4188,9 +4018,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(OverlaySrcAtop(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(OverlaySrcAtop(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -4206,9 +4034,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(OverlaySrcOver(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(OverlaySrcOver(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -4224,9 +4050,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(OverlaySrcIn(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(OverlaySrcIn(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -4242,9 +4066,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(OverlaySrcOut(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(OverlaySrcOut(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -4260,9 +4082,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(OverlayDest(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(OverlayDest(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -4278,9 +4098,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(OverlayDestAtop(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(OverlayDestAtop(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -4296,9 +4114,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(OverlayDestOver(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(OverlayDestOver(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -4314,9 +4130,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(OverlayDestIn(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(OverlayDestIn(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -4332,9 +4146,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(OverlayDestOut(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(OverlayDestOut(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -4350,9 +4162,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(OverlayClear(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(OverlayClear(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -4368,9 +4178,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(OverlayXor(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(OverlayXor(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -4715,9 +4523,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(HardLightSrc(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(HardLightSrc(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -4733,9 +4539,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(HardLightSrcAtop(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(HardLightSrcAtop(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -4751,9 +4555,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(HardLightSrcOver(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(HardLightSrcOver(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -4769,9 +4571,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(HardLightSrcIn(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(HardLightSrcIn(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -4787,9 +4587,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(HardLightSrcOut(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(HardLightSrcOut(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -4805,9 +4603,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(HardLightDest(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(HardLightDest(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -4823,9 +4619,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(HardLightDestAtop(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(HardLightDestAtop(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -4841,9 +4635,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(HardLightDestOver(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(HardLightDestOver(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -4859,9 +4651,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(HardLightDestIn(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(HardLightDestIn(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -4877,9 +4667,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(HardLightDestOut(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(HardLightDestOut(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -4895,9 +4683,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(HardLightClear(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(HardLightClear(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 
     /// <summary>
@@ -4913,8 +4699,6 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(HardLightXor(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(HardLightXor(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 }
diff --git a/src/ImageSharp/PixelFormats/PixelBlenders/PorterDuffFunctions.Generated.tt b/src/ImageSharp/PixelFormats/PixelBlenders/PorterDuffFunctions.Generated.tt
index 64eee502b..150adb33a 100644
--- a/src/ImageSharp/PixelFormats/PixelBlenders/PorterDuffFunctions.Generated.tt
+++ b/src/ImageSharp/PixelFormats/PixelBlenders/PorterDuffFunctions.Generated.tt
@@ -368,9 +368,7 @@ internal static partial class PorterDuffFunctions
         where TPixel : unmanaged, IPixel<TPixel>
     {
         opacity = Numerics.Clamp(opacity, 0, 1);
-        TPixel dest = default;
-        dest.FromScaledVector4(<#=blender#><#=composer#>(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
-        return dest;
+        return TPixel.FromScaledVector4(<#=blender#><#=composer#>(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
     }
 <# } #>
 <#
diff --git a/src/ImageSharp/PixelFormats/PixelColorType.cs b/src/ImageSharp/PixelFormats/PixelColorType.cs
new file mode 100644
index 000000000..9ac2c308c
--- /dev/null
+++ b/src/ImageSharp/PixelFormats/PixelColorType.cs
@@ -0,0 +1,46 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.PixelFormats;
+
+/// <summary>
+/// Represents the color type and format of a pixel.
+/// </summary>
+[Flags]
+public enum PixelColorType
+{
+    /// <summary>
+    /// Represents the Red component of the color.
+    /// </summary>
+    Red = 1 << 0,
+
+    /// <summary>
+    /// Represents the Green component of the color.
+    /// </summary>
+    Green = 1 << 1,
+
+    /// <summary>
+    /// Represents the Blue component of the color.
+    /// </summary>
+    Blue = 1 << 2,
+
+    /// <summary>
+    /// Represents the Alpha component of the color for transparency.
+    /// </summary>
+    Alpha = 1 << 3,
+
+    /// <summary>
+    /// Indicates that the color is in grayscale.
+    /// </summary>
+    Grayscale = 1 << 4,
+
+    /// <summary>
+    /// Indicates that the color is in RGB (Red, Green, Blue) format.
+    /// </summary>
+    RGB = Red | Green | Blue | (1 << 5),
+
+    /// <summary>
+    /// Indicates that the color is in BGR (Blue, Green, Red) format.
+    /// </summary>
+    BGR = Blue | Green | Red | (1 << 6)
+}
diff --git a/src/ImageSharp/PixelFormats/PixelComponentBitDepth.cs b/src/ImageSharp/PixelFormats/PixelComponentBitDepth.cs
new file mode 100644
index 000000000..674c9363b
--- /dev/null
+++ b/src/ImageSharp/PixelFormats/PixelComponentBitDepth.cs
@@ -0,0 +1,50 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.PixelFormats;
+
+/// <summary>
+/// Provides enumeration of the precision in bits of individual components within a pixel format.
+/// </summary>
+public enum PixelComponentBitDepth
+{
+    /// <summary>
+    /// 1 bit per component.
+    /// </summary>
+    Bit1 = 1,
+
+    /// <summary>
+    /// 2 bits per component.
+    /// </summary>
+    Bit2 = 2,
+
+    /// <summary>
+    /// 4 bits per component.
+    /// </summary>
+    Bit4 = 4,
+
+    /// <summary>
+    /// 8 bits per component.
+    /// </summary>
+    Bit8 = 8,
+
+    /// <summary>
+    /// 16 bits per component.
+    /// </summary>
+    Bit16 = 16,
+
+    /// <summary>
+    /// 32 bits per component.
+    /// </summary>
+    Bit32 = 32,
+
+    /// <summary>
+    /// 64 bits per component.
+    /// </summary>
+    Bit64 = 64,
+
+    /// <summary>
+    /// 128 bits per component.
+    /// </summary>
+    Bit128 = 128
+}
diff --git a/src/ImageSharp/PixelFormats/PixelComponentInfo.cs b/src/ImageSharp/PixelFormats/PixelComponentInfo.cs
new file mode 100644
index 000000000..a76105414
--- /dev/null
+++ b/src/ImageSharp/PixelFormats/PixelComponentInfo.cs
@@ -0,0 +1,111 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+
+namespace SixLabors.ImageSharp.PixelFormats;
+
+/// <summary>
+/// Represents pixel component information within a pixel format.
+/// </summary>
+public readonly struct PixelComponentInfo
+{
+    private readonly long precisionData1;
+    private readonly long precisionData2;
+
+    private PixelComponentInfo(int count, int padding, long precisionData1, long precisionData2)
+    {
+        this.ComponentCount = count;
+        this.Padding = padding;
+        this.precisionData1 = precisionData1;
+        this.precisionData2 = precisionData2;
+    }
+
+    /// <summary>
+    /// Gets the number of components within the pixel.
+    /// </summary>
+    public int ComponentCount { get; }
+
+    /// <summary>
+    /// Gets the number of bytes of padding within the pixel.
+    /// </summary>
+    public int Padding { get; }
+
+    /// <summary>
+    /// Creates a new <see cref="PixelComponentInfo"/> instance.
+    /// </summary>
+    /// <typeparam name="TPixel">The type of pixel format.</typeparam>
+    /// <param name="count">The number of components within the pixel format.</param>
+    /// <param name="precision">The precision in bits of each component.</param>
+    /// <returns>The <see cref="PixelComponentInfo"/>.</returns>
+    /// <exception cref="ArgumentOutOfRangeException">The component precision and index cannot exceed the component range.</exception>
+    public static PixelComponentInfo Create<TPixel>(int count, params int[] precision)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        if (precision.Length != count || precision.Length > 16)
+        {
+            throw new ArgumentException($"Count must match the length of precision array and cannot exceed 16.");
+        }
+
+        long precisionData1 = 0;
+        long precisionData2 = 0;
+        int sum = 0;
+        for (int i = 0; i < precision.Length; i++)
+        {
+            int p = precision[i];
+            if (p is < 0 or > 255)
+            {
+                throw new ArgumentException("Precision must be between 0 and 255.");
+            }
+
+            if (i < 8)
+            {
+                precisionData1 |= ((long)p) << (8 * i);
+            }
+            else
+            {
+                precisionData2 |= ((long)p) << (8 * (i - 8));
+            }
+
+            sum += p;
+        }
+
+        return new PixelComponentInfo(count, (Unsafe.SizeOf<TPixel>() * 8) - sum, precisionData1, precisionData2);
+    }
+
+    /// <summary>
+    /// Returns the precision of the component in bits at the given index.
+    /// </summary>
+    /// <param name="componentIndex">The component index.</param>
+    /// <returns>The <see cref="int"/>.</returns>
+    /// <exception cref="ArgumentOutOfRangeException">The component index cannot exceed the component range.</exception>
+    public int GetComponentPrecision(int componentIndex)
+    {
+        if (componentIndex < 0 || componentIndex >= this.ComponentCount)
+        {
+            throw new ArgumentOutOfRangeException($"Component index must be between 0 and {this.ComponentCount - 1} inclusive.");
+        }
+
+        long selectedPrecisionData = componentIndex < 8 ? this.precisionData1 : this.precisionData2;
+        return (int)((selectedPrecisionData >> (8 * (componentIndex & 7))) & 0xFF);
+    }
+
+    /// <summary>
+    /// Returns the maximum precision in bits of all components.
+    /// </summary>
+    /// <returns>The <see cref="int"/>.</returns>
+    public int GetMaximumComponentPrecision()
+    {
+        int maxPrecision = 0;
+        for (int i = 0; i < this.ComponentCount; i++)
+        {
+            int componentPrecision = this.GetComponentPrecision(i);
+            if (componentPrecision > maxPrecision)
+            {
+                maxPrecision = componentPrecision;
+            }
+        }
+
+        return maxPrecision;
+    }
+}
diff --git a/src/ImageSharp/PixelFormats/PixelConversionModifiers.cs b/src/ImageSharp/PixelFormats/PixelConversionModifiers.cs
index 9db3d3004..25fc74e08 100644
--- a/src/ImageSharp/PixelFormats/PixelConversionModifiers.cs
+++ b/src/ImageSharp/PixelFormats/PixelConversionModifiers.cs
@@ -1,4 +1,4 @@
-// Copyright (c) Six Labors.
+// Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
 using SixLabors.ImageSharp.ColorSpaces.Companding;
@@ -7,9 +7,9 @@ namespace SixLabors.ImageSharp.PixelFormats;
 
 /// <summary>
 /// Flags responsible to select additional operations which could be efficiently applied in
-/// <see cref="PixelOperations{TPixel}.ToVector4(SixLabors.ImageSharp.Configuration,System.ReadOnlySpan{TPixel},System.Span{System.Numerics.Vector4},SixLabors.ImageSharp.PixelFormats.PixelConversionModifiers)"/>
+/// <see cref="PixelOperations{TPixel}.ToVector4(Configuration,ReadOnlySpan{TPixel},Span{System.Numerics.Vector4},PixelConversionModifiers)"/>
 /// or
-/// <see cref="PixelOperations{TPixel}.FromVector4Destructive(SixLabors.ImageSharp.Configuration,System.Span{System.Numerics.Vector4},System.Span{TPixel},SixLabors.ImageSharp.PixelFormats.PixelConversionModifiers)"/>
+/// <see cref="PixelOperations{TPixel}.FromVector4Destructive(Configuration,Span{System.Numerics.Vector4},Span{TPixel},PixelConversionModifiers)"/>
 /// knowing the pixel type.
 /// </summary>
 [Flags]
@@ -21,7 +21,7 @@ public enum PixelConversionModifiers
     None = 0,
 
     /// <summary>
-    /// Select <see cref="IPixel.ToScaledVector4"/> and <see cref="IPixel.FromScaledVector4"/> instead the standard (non scaled) variants.
+    /// Select <see cref="IPixel.ToScaledVector4"/> and <see cref="IPixel{T}.FromScaledVector4"/> instead the standard (non scaled) variants.
     /// </summary>
     Scale = 1 << 0,
 
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/A8.cs b/src/ImageSharp/PixelFormats/PixelImplementations/A8.cs
index 025690712..94fbf7eb7 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/A8.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/A8.cs
@@ -41,7 +41,7 @@ public partial struct A8 : IPixel<A8>, IPackedVector<byte>
     /// <returns>
     /// True if the <paramref name="left"/> parameter is equal to the <paramref name="right"/> parameter; otherwise, false.
     /// </returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator ==(A8 left, A8 right) => left.Equals(right);
 
     /// <summary>
@@ -52,87 +52,90 @@ public partial struct A8 : IPixel<A8>, IPackedVector<byte>
     /// <returns>
     /// True if the <paramref name="left"/> parameter is not equal to the <paramref name="right"/> parameter; otherwise, false.
     /// </returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator !=(A8 left, A8 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public readonly PixelOperations<A8> CreatePixelOperations() => new PixelOperations();
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly Rgba32 ToRgba32() => new() { A = this.PackedValue };
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromScaledVector4(Vector4 vector) => this.FromVector4(vector);
-
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public readonly Vector4 ToScaledVector4() => this.ToVector4();
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromVector4(Vector4 vector) => this.PackedValue = Pack(vector.W);
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly Vector4 ToVector4() => new(0, 0, 0, this.PackedValue / 255f);
+
+    /// <inheritdoc/>
+    public static PixelTypeInfo GetPixelTypeInfo()
+        => PixelTypeInfo.Create<A8>(
+            PixelComponentInfo.Create<A8>(1, 8),
+            PixelColorType.Alpha,
+            PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public readonly Vector4 ToVector4() => new(0, 0, 0, this.PackedValue / 255F);
+    public static PixelOperations<A8> CreatePixelOperations() => new PixelOperations();
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromArgb32(Argb32 source) => this.PackedValue = source.A;
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static A8 FromScaledVector4(Vector4 source) => FromVector4(source);
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgr24(Bgr24 source) => this.PackedValue = byte.MaxValue;
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static A8 FromVector4(Vector4 source) => new(Pack(source.W));
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgra32(Bgra32 source) => this.PackedValue = source.A;
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static A8 FromAbgr32(Abgr32 source) => new(source.A);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromAbgr32(Abgr32 source) => this.PackedValue = source.A;
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static A8 FromArgb32(Argb32 source) => new(source.A);
+
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static A8 FromBgra5551(Bgra5551 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgra5551(Bgra5551 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static A8 FromBgr24(Bgr24 source) => new(byte.MaxValue);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromL8(L8 source) => this.PackedValue = byte.MaxValue;
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static A8 FromBgra32(Bgra32 source) => new(source.A);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromL16(L16 source) => this.PackedValue = byte.MaxValue;
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static A8 FromL8(L8 source) => new(byte.MaxValue);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromLa16(La16 source) => this.PackedValue = source.A;
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static A8 FromL16(L16 source) => new(byte.MaxValue);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromLa32(La32 source) => this.PackedValue = ColorNumerics.DownScaleFrom16BitTo8Bit(source.A);
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static A8 FromLa16(La16 source) => new(source.A);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgb24(Rgb24 source) => this.PackedValue = byte.MaxValue;
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static A8 FromLa32(La32 source) => new(ColorNumerics.From16BitTo8Bit(source.A));
 
-    /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgba32(Rgba32 source) => this.PackedValue = source.A;
+    /// <inheritdoc/>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static A8 FromRgb24(Rgb24 source) => new(byte.MaxValue);
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void ToRgba32(ref Rgba32 dest)
-    {
-        dest = default;
-        dest.A = this.PackedValue;
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static A8 FromRgba32(Rgba32 source) => new(source.A);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgb48(Rgb48 source) => this.PackedValue = byte.MaxValue;
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static A8 FromRgb48(Rgb48 source) => new(byte.MaxValue);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgba64(Rgba64 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static A8 FromRgba64(Rgba64 source) => new(ColorNumerics.From16BitTo8Bit(source.A));
 
     /// <summary>
     /// Compares an object with the packed vector.
@@ -146,7 +149,6 @@ public partial struct A8 : IPixel<A8>, IPackedVector<byte>
     /// </summary>
     /// <param name="other">The A8 packed vector to compare.</param>
     /// <returns>True if the packed vectors are equal.</returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
     public readonly bool Equals(A8 other) => this.PackedValue.Equals(other.PackedValue);
 
     /// <summary>
@@ -156,7 +158,6 @@ public partial struct A8 : IPixel<A8>, IPackedVector<byte>
     public override readonly string ToString() => $"A8({this.PackedValue})";
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
     public override readonly int GetHashCode() => this.PackedValue.GetHashCode();
 
     /// <summary>
@@ -164,6 +165,6 @@ public partial struct A8 : IPixel<A8>, IPackedVector<byte>
     /// </summary>
     /// <param name="alpha">The float containing the value to pack.</param>
     /// <returns>The <see cref="byte"/> containing the packed values.</returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    private static byte Pack(float alpha) => (byte)Math.Round(Numerics.Clamp(alpha, 0, 1F) * 255F);
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static byte Pack(float alpha) => (byte)Math.Round(Numerics.Clamp(alpha, 0, 1f) * 255f);
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Abgr32.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Abgr32.cs
index 8bd24c7a0..453a39228 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Abgr32.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Abgr32.cs
@@ -4,6 +4,7 @@
 using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics;
 
 namespace SixLabors.ImageSharp.PixelFormats;
 
@@ -44,12 +45,12 @@ public partial struct Abgr32 : IPixel<Abgr32>, IPackedVector<uint>
     /// <summary>
     /// The maximum byte value.
     /// </summary>
-    private static readonly Vector4 MaxBytes = new(255);
+    private static readonly Vector4 MaxBytes = Vector128.Create(255f).AsVector4();
 
     /// <summary>
     /// The half vector value.
     /// </summary>
-    private static readonly Vector4 Half = new(0.5F);
+    private static readonly Vector4 Half = Vector128.Create(.5f).AsVector4();
 
     /// <summary>
     /// Initializes a new instance of the <see cref="Abgr32"/> struct.
@@ -57,7 +58,7 @@ public partial struct Abgr32 : IPixel<Abgr32>, IPackedVector<uint>
     /// <param name="r">The red component.</param>
     /// <param name="g">The green component.</param>
     /// <param name="b">The blue component.</param>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public Abgr32(byte r, byte g, byte b)
     {
         this.R = r;
@@ -73,7 +74,7 @@ public partial struct Abgr32 : IPixel<Abgr32>, IPackedVector<uint>
     /// <param name="g">The green component.</param>
     /// <param name="b">The blue component.</param>
     /// <param name="a">The alpha component.</param>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public Abgr32(byte r, byte g, byte b, byte a)
     {
         this.R = r;
@@ -89,9 +90,11 @@ public partial struct Abgr32 : IPixel<Abgr32>, IPackedVector<uint>
     /// <param name="g">The green component.</param>
     /// <param name="b">The blue component.</param>
     /// <param name="a">The alpha component.</param>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public Abgr32(float r, float g, float b, float a = 1)
-        : this() => this.Pack(r, g, b, a);
+        : this(new Vector4(r, g, b, a))
+    {
+    }
 
     /// <summary>
     /// Initializes a new instance of the <see cref="Abgr32"/> struct.
@@ -99,9 +102,11 @@ public partial struct Abgr32 : IPixel<Abgr32>, IPackedVector<uint>
     /// <param name="vector">
     /// The vector containing the components for the packed vector.
     /// </param>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public Abgr32(Vector3 vector)
-        : this() => this.Pack(ref vector);
+        : this(new Vector4(vector, 1f))
+    {
+    }
 
     /// <summary>
     /// Initializes a new instance of the <see cref="Abgr32"/> struct.
@@ -109,9 +114,9 @@ public partial struct Abgr32 : IPixel<Abgr32>, IPackedVector<uint>
     /// <param name="vector">
     /// The vector containing the components for the packed vector.
     /// </param>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public Abgr32(Vector4 vector)
-        : this() => this.Pack(ref vector);
+        : this() => this = Pack(vector);
 
     /// <summary>
     /// Initializes a new instance of the <see cref="Abgr32"/> struct.
@@ -119,48 +124,32 @@ public partial struct Abgr32 : IPixel<Abgr32>, IPackedVector<uint>
     /// <param name="packed">
     /// The packed value.
     /// </param>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public Abgr32(uint packed)
         : this() => this.Abgr = packed;
 
     /// <summary>
-    /// Gets or sets the packed representation of the Abgrb32 struct.
+    /// Gets or sets the packed representation of the Abgr struct.
     /// </summary>
     public uint Abgr
     {
-        [MethodImpl(InliningOptions.ShortMethod)]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         readonly get => Unsafe.As<Abgr32, uint>(ref Unsafe.AsRef(in this));
 
-        [MethodImpl(InliningOptions.ShortMethod)]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         set => Unsafe.As<Abgr32, uint>(ref this) = value;
     }
 
     /// <inheritdoc/>
     public uint PackedValue
     {
-        [MethodImpl(InliningOptions.ShortMethod)]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         readonly get => this.Abgr;
 
-        [MethodImpl(InliningOptions.ShortMethod)]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         set => this.Abgr = value;
     }
 
-    /// <summary>
-    /// Converts an <see cref="Abgr32"/> to <see cref="Color"/>.
-    /// </summary>
-    /// <param name="source">The <see cref="Abgr32"/>.</param>
-    /// <returns>The <see cref="Color"/>.</returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public static implicit operator Color(Abgr32 source) => new(source);
-
-    /// <summary>
-    /// Converts a <see cref="Color"/> to <see cref="Abgr32"/>.
-    /// </summary>
-    /// <param name="color">The <see cref="Color"/>.</param>
-    /// <returns>The <see cref="Abgr32"/>.</returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public static implicit operator Abgr32(Color color) => color.ToAbgr32();
-
     /// <summary>
     /// Compares two <see cref="Argb32"/> objects for equality.
     /// </summary>
@@ -169,7 +158,7 @@ public partial struct Abgr32 : IPixel<Abgr32>, IPackedVector<uint>
     /// <returns>
     /// True if the <paramref name="left"/> parameter is equal to the <paramref name="right"/> parameter; otherwise, false.
     /// </returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator ==(Abgr32 left, Abgr32 right) => left.Equals(right);
 
     /// <summary>
@@ -180,164 +169,117 @@ public partial struct Abgr32 : IPixel<Abgr32>, IPackedVector<uint>
     /// <returns>
     /// True if the <paramref name="left"/> parameter is not equal to the <paramref name="right"/> parameter; otherwise, false.
     /// </returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator !=(Abgr32 left, Abgr32 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public readonly PixelOperations<Abgr32> CreatePixelOperations() => new PixelOperations();
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly Rgba32 ToRgba32() => Rgba32.FromAbgr32(this);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromScaledVector4(Vector4 vector) => this.FromVector4(vector);
-
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public readonly Vector4 ToScaledVector4() => this.ToVector4();
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromVector4(Vector4 vector) => this.Pack(ref vector);
-
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public readonly Vector4 ToVector4() => new Vector4(this.R, this.G, this.B, this.A) / MaxBytes;
 
+    /// <inheritdoc />
+    public static PixelTypeInfo GetPixelTypeInfo()
+        => PixelTypeInfo.Create<Abgr32>(
+            PixelComponentInfo.Create<Abgr32>(4, 8, 8, 8, 8),
+            PixelColorType.Alpha | PixelColorType.BGR,
+            PixelAlphaRepresentation.Unassociated);
+
+    /// <inheritdoc />
+    public static PixelOperations<Abgr32> CreatePixelOperations() => new PixelOperations();
+
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromAbgr32(Abgr32 source) => this = source;
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Abgr32 FromScaledVector4(Vector4 source) => FromVector4(source);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgra5551(Bgra5551 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Abgr32 FromVector4(Vector4 source) => Pack(source);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgr24(Bgr24 source)
-    {
-        // We can assign the Bgr24 value directly to last three bytes of this instance.
-        ref byte thisRef = ref Unsafe.As<Abgr32, byte>(ref this);
-        ref byte thisRefFromB = ref Unsafe.AddByteOffset(ref thisRef, 1);
-        Unsafe.As<byte, Bgr24>(ref thisRefFromB) = source;
-        this.A = byte.MaxValue;
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Abgr32 FromAbgr32(Abgr32 source) => new() { PackedValue = source.PackedValue };
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromArgb32(Argb32 source)
-    {
-        this.R = source.R;
-        this.G = source.G;
-        this.B = source.B;
-        this.A = source.A;
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Abgr32 FromArgb32(Argb32 source) => new(source.R, source.G, source.B, source.A);
+
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Abgr32 FromBgra5551(Bgra5551 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgra32(Bgra32 source)
-    {
-        this.R = source.R;
-        this.G = source.G;
-        this.B = source.B;
-        this.A = source.A;
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Abgr32 FromBgr24(Bgr24 source) => new(source.R, source.G, source.B);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromL8(L8 source)
-    {
-        this.R = source.PackedValue;
-        this.G = source.PackedValue;
-        this.B = source.PackedValue;
-        this.A = byte.MaxValue;
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Abgr32 FromBgra32(Bgra32 source) => new(source.R, source.G, source.B, source.A);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromL16(L16 source)
-    {
-        byte rgb = ColorNumerics.DownScaleFrom16BitTo8Bit(source.PackedValue);
-        this.R = rgb;
-        this.G = rgb;
-        this.B = rgb;
-        this.A = byte.MaxValue;
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Abgr32 FromL8(L8 source) => new(source.PackedValue, source.PackedValue, source.PackedValue);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromLa16(La16 source)
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Abgr32 FromL16(L16 source)
     {
-        this.R = source.L;
-        this.G = source.L;
-        this.B = source.L;
-        this.A = source.A;
+        byte rgb = ColorNumerics.From16BitTo8Bit(source.PackedValue);
+        return new(rgb, rgb, rgb);
     }
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromLa32(La32 source)
-    {
-        byte rgb = ColorNumerics.DownScaleFrom16BitTo8Bit(source.L);
-        this.R = rgb;
-        this.G = rgb;
-        this.B = rgb;
-        this.A = ColorNumerics.DownScaleFrom16BitTo8Bit(source.A);
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Abgr32 FromLa16(La16 source) => new(source.L, source.L, source.L, source.A);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgb24(Rgb24 source)
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Abgr32 FromLa32(La32 source)
     {
-        this.R = source.R;
-        this.G = source.G;
-        this.B = source.B;
-        this.A = byte.MaxValue;
+        byte rgb = ColorNumerics.From16BitTo8Bit(source.L);
+        return new(rgb, rgb, rgb, ColorNumerics.From16BitTo8Bit(source.A));
     }
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgba32(Rgba32 source)
-    {
-        this.R = source.R;
-        this.G = source.G;
-        this.B = source.B;
-        this.A = source.A;
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Abgr32 FromRgb24(Rgb24 source) => new(source.R, source.G, source.B);
 
-    /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void ToRgba32(ref Rgba32 dest)
-    {
-        dest.R = this.R;
-        dest.G = this.G;
-        dest.B = this.B;
-        dest.A = this.A;
-    }
+    /// <inheritdoc/>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Abgr32 FromRgba32(Rgba32 source) => new(source.R, source.G, source.B, source.A);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgb48(Rgb48 source)
-    {
-        this.R = ColorNumerics.DownScaleFrom16BitTo8Bit(source.R);
-        this.G = ColorNumerics.DownScaleFrom16BitTo8Bit(source.G);
-        this.B = ColorNumerics.DownScaleFrom16BitTo8Bit(source.B);
-        this.A = byte.MaxValue;
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Abgr32 FromRgb48(Rgb48 source)
+        => new()
+        {
+            R = ColorNumerics.From16BitTo8Bit(source.R),
+            G = ColorNumerics.From16BitTo8Bit(source.G),
+            B = ColorNumerics.From16BitTo8Bit(source.B),
+            A = byte.MaxValue
+        };
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgba64(Rgba64 source)
-    {
-        this.R = ColorNumerics.DownScaleFrom16BitTo8Bit(source.R);
-        this.G = ColorNumerics.DownScaleFrom16BitTo8Bit(source.G);
-        this.B = ColorNumerics.DownScaleFrom16BitTo8Bit(source.B);
-        this.A = ColorNumerics.DownScaleFrom16BitTo8Bit(source.A);
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Abgr32 FromRgba64(Rgba64 source)
+        => new()
+        {
+            R = ColorNumerics.From16BitTo8Bit(source.R),
+            G = ColorNumerics.From16BitTo8Bit(source.G),
+            B = ColorNumerics.From16BitTo8Bit(source.B),
+            A = ColorNumerics.From16BitTo8Bit(source.A)
+        };
 
     /// <inheritdoc/>
     public override readonly bool Equals(object? obj) => obj is Abgr32 abgr32 && this.Equals(abgr32);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
     public readonly bool Equals(Abgr32 other) => this.Abgr == other.Abgr;
 
     /// <summary>
@@ -347,7 +289,6 @@ public partial struct Abgr32 : IPixel<Abgr32>, IPackedVector<uint>
     public override readonly string ToString() => $"Abgr({this.A}, {this.B}, {this.G}, {this.R})";
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
     public override readonly int GetHashCode() => this.Abgr.GetHashCode();
 
     /// <summary>
@@ -357,38 +298,28 @@ public partial struct Abgr32 : IPixel<Abgr32>, IPackedVector<uint>
     /// <param name="y">The y-component</param>
     /// <param name="z">The z-component</param>
     /// <param name="w">The w-component</param>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    private void Pack(float x, float y, float z, float w)
-    {
-        var value = new Vector4(x, y, z, w);
-        this.Pack(ref value);
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static Abgr32 Pack(float x, float y, float z, float w) => Pack(new Vector4(x, y, z, w));
 
     /// <summary>
     /// Packs a <see cref="Vector3"/> into a uint.
     /// </summary>
     /// <param name="vector">The vector containing the values to pack.</param>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    private void Pack(ref Vector3 vector)
-    {
-        var value = new Vector4(vector, 1);
-        this.Pack(ref value);
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static Abgr32 Pack(Vector3 vector) => Pack(new Vector4(vector, 1));
 
     /// <summary>
     /// Packs a <see cref="Vector4"/> into a color.
     /// </summary>
     /// <param name="vector">The vector containing the values to pack.</param>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    private void Pack(ref Vector4 vector)
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static Abgr32 Pack(Vector4 vector)
     {
         vector *= MaxBytes;
         vector += Half;
         vector = Numerics.Clamp(vector, Vector4.Zero, MaxBytes);
 
-        this.R = (byte)vector.X;
-        this.G = (byte)vector.Y;
-        this.B = (byte)vector.Z;
-        this.A = (byte)vector.W;
+        Vector128<byte> result = Vector128.ConvertToInt32(vector.AsVector128()).AsByte();
+        return new(result.GetElement(0), result.GetElement(4), result.GetElement(8), result.GetElement(12));
     }
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Argb32.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Argb32.cs
index fa8af98a0..f8608ecc5 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Argb32.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Argb32.cs
@@ -4,6 +4,7 @@
 using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics;
 
 namespace SixLabors.ImageSharp.PixelFormats;
 
@@ -41,15 +42,8 @@ public partial struct Argb32 : IPixel<Argb32>, IPackedVector<uint>
     /// </summary>
     public byte B;
 
-    /// <summary>
-    /// The maximum byte value.
-    /// </summary>
-    private static readonly Vector4 MaxBytes = new(255);
-
-    /// <summary>
-    /// The half vector value.
-    /// </summary>
-    private static readonly Vector4 Half = new(0.5F);
+    private static readonly Vector4 MaxBytes = Vector128.Create(255f).AsVector4();
+    private static readonly Vector4 Half = Vector128.Create(.5f).AsVector4();
 
     /// <summary>
     /// Initializes a new instance of the <see cref="Argb32"/> struct.
@@ -57,7 +51,7 @@ public partial struct Argb32 : IPixel<Argb32>, IPackedVector<uint>
     /// <param name="r">The red component.</param>
     /// <param name="g">The green component.</param>
     /// <param name="b">The blue component.</param>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public Argb32(byte r, byte g, byte b)
     {
         this.R = r;
@@ -73,7 +67,7 @@ public partial struct Argb32 : IPixel<Argb32>, IPackedVector<uint>
     /// <param name="g">The green component.</param>
     /// <param name="b">The blue component.</param>
     /// <param name="a">The alpha component.</param>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public Argb32(byte r, byte g, byte b, byte a)
     {
         this.R = r;
@@ -89,9 +83,11 @@ public partial struct Argb32 : IPixel<Argb32>, IPackedVector<uint>
     /// <param name="g">The green component.</param>
     /// <param name="b">The blue component.</param>
     /// <param name="a">The alpha component.</param>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public Argb32(float r, float g, float b, float a = 1)
-        : this() => this.Pack(r, g, b, a);
+        : this(new Vector4(r, g, b, a))
+    {
+    }
 
     /// <summary>
     /// Initializes a new instance of the <see cref="Argb32"/> struct.
@@ -99,9 +95,11 @@ public partial struct Argb32 : IPixel<Argb32>, IPackedVector<uint>
     /// <param name="vector">
     /// The vector containing the components for the packed vector.
     /// </param>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public Argb32(Vector3 vector)
-        : this() => this.Pack(ref vector);
+        : this(new Vector4(vector, 1f))
+    {
+    }
 
     /// <summary>
     /// Initializes a new instance of the <see cref="Argb32"/> struct.
@@ -109,9 +107,9 @@ public partial struct Argb32 : IPixel<Argb32>, IPackedVector<uint>
     /// <param name="vector">
     /// The vector containing the components for the packed vector.
     /// </param>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public Argb32(Vector4 vector)
-        : this() => this.Pack(ref vector);
+        : this() => this = Pack(vector);
 
     /// <summary>
     /// Initializes a new instance of the <see cref="Argb32"/> struct.
@@ -119,7 +117,7 @@ public partial struct Argb32 : IPixel<Argb32>, IPackedVector<uint>
     /// <param name="packed">
     /// The packed value.
     /// </param>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public Argb32(uint packed)
         : this() => this.Argb = packed;
 
@@ -128,39 +126,23 @@ public partial struct Argb32 : IPixel<Argb32>, IPackedVector<uint>
     /// </summary>
     public uint Argb
     {
-        [MethodImpl(InliningOptions.ShortMethod)]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         readonly get => Unsafe.As<Argb32, uint>(ref Unsafe.AsRef(in this));
 
-        [MethodImpl(InliningOptions.ShortMethod)]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         set => Unsafe.As<Argb32, uint>(ref this) = value;
     }
 
     /// <inheritdoc/>
     public uint PackedValue
     {
-        [MethodImpl(InliningOptions.ShortMethod)]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         readonly get => this.Argb;
 
-        [MethodImpl(InliningOptions.ShortMethod)]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         set => this.Argb = value;
     }
 
-    /// <summary>
-    /// Converts an <see cref="Argb32"/> to <see cref="Color"/>.
-    /// </summary>
-    /// <param name="source">The <see cref="Argb32"/>.</param>
-    /// <returns>The <see cref="Color"/>.</returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public static implicit operator Color(Argb32 source) => new(source);
-
-    /// <summary>
-    /// Converts a <see cref="Color"/> to <see cref="Argb32"/>.
-    /// </summary>
-    /// <param name="color">The <see cref="Color"/>.</param>
-    /// <returns>The <see cref="Argb32"/>.</returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public static implicit operator Argb32(Color color) => color.ToArgb32();
-
     /// <summary>
     /// Compares two <see cref="Argb32"/> objects for equality.
     /// </summary>
@@ -169,7 +151,7 @@ public partial struct Argb32 : IPixel<Argb32>, IPackedVector<uint>
     /// <returns>
     /// True if the <paramref name="left"/> parameter is equal to the <paramref name="right"/> parameter; otherwise, false.
     /// </returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator ==(Argb32 left, Argb32 right) => left.Equals(right);
 
     /// <summary>
@@ -180,163 +162,117 @@ public partial struct Argb32 : IPixel<Argb32>, IPackedVector<uint>
     /// <returns>
     /// True if the <paramref name="left"/> parameter is not equal to the <paramref name="right"/> parameter; otherwise, false.
     /// </returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator !=(Argb32 left, Argb32 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public readonly PixelOperations<Argb32> CreatePixelOperations() => new PixelOperations();
-
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromScaledVector4(Vector4 vector) => this.FromVector4(vector);
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly Rgba32 ToRgba32() => Rgba32.FromArgb32(this);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public readonly Vector4 ToScaledVector4() => this.ToVector4();
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromVector4(Vector4 vector) => this.Pack(ref vector);
-
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public readonly Vector4 ToVector4() => new Vector4(this.R, this.G, this.B, this.A) / MaxBytes;
 
+    /// <inheritdoc />
+    public static PixelTypeInfo GetPixelTypeInfo()
+        => PixelTypeInfo.Create<Argb32>(
+            PixelComponentInfo.Create<Argb32>(4, 8, 8, 8, 8),
+            PixelColorType.Alpha | PixelColorType.RGB,
+            PixelAlphaRepresentation.Unassociated);
+
+    /// <inheritdoc />
+    public static PixelOperations<Argb32> CreatePixelOperations() => new PixelOperations();
+
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromArgb32(Argb32 source) => this.PackedValue = source.PackedValue;
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Argb32 FromScaledVector4(Vector4 source) => FromVector4(source);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgra5551(Bgra5551 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Argb32 FromVector4(Vector4 source) => Pack(source);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgr24(Bgr24 source)
-    {
-        this.R = source.R;
-        this.G = source.G;
-        this.B = source.B;
-        this.A = byte.MaxValue;
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Argb32 FromAbgr32(Abgr32 source) => new(source.R, source.G, source.B, source.A);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgra32(Bgra32 source)
-    {
-        this.R = source.R;
-        this.G = source.G;
-        this.B = source.B;
-        this.A = source.A;
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Argb32 FromArgb32(Argb32 source) => new() { PackedValue = source.PackedValue };
+
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Argb32 FromBgra5551(Bgra5551 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromAbgr32(Abgr32 source)
-    {
-        this.R = source.R;
-        this.G = source.G;
-        this.B = source.B;
-        this.A = source.A;
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Argb32 FromBgr24(Bgr24 source) => new(source.R, source.G, source.B);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromL8(L8 source)
-    {
-        this.R = source.PackedValue;
-        this.G = source.PackedValue;
-        this.B = source.PackedValue;
-        this.A = byte.MaxValue;
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Argb32 FromBgra32(Bgra32 source) => new(source.R, source.G, source.B, source.A);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromL16(L16 source)
-    {
-        byte rgb = ColorNumerics.DownScaleFrom16BitTo8Bit(source.PackedValue);
-        this.R = rgb;
-        this.G = rgb;
-        this.B = rgb;
-        this.A = byte.MaxValue;
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Argb32 FromL8(L8 source) => new(source.PackedValue, source.PackedValue, source.PackedValue);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromLa16(La16 source)
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Argb32 FromL16(L16 source)
     {
-        this.R = source.L;
-        this.G = source.L;
-        this.B = source.L;
-        this.A = source.A;
+        byte rgb = ColorNumerics.From16BitTo8Bit(source.PackedValue);
+        return new(rgb, rgb, rgb);
     }
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromLa32(La32 source)
-    {
-        byte rgb = ColorNumerics.DownScaleFrom16BitTo8Bit(source.L);
-        this.R = rgb;
-        this.G = rgb;
-        this.B = rgb;
-        this.A = ColorNumerics.DownScaleFrom16BitTo8Bit(source.A);
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Argb32 FromLa16(La16 source) => new(source.L, source.L, source.L, source.A);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgb24(Rgb24 source)
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Argb32 FromLa32(La32 source)
     {
-        this.R = source.R;
-        this.G = source.G;
-        this.B = source.B;
-        this.A = byte.MaxValue;
+        byte rgb = ColorNumerics.From16BitTo8Bit(source.L);
+        return new(rgb, rgb, rgb, ColorNumerics.From16BitTo8Bit(source.A));
     }
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgba32(Rgba32 source)
-    {
-        this.R = source.R;
-        this.G = source.G;
-        this.B = source.B;
-        this.A = source.A;
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Argb32 FromRgb24(Rgb24 source) => new(source.R, source.G, source.B);
 
-    /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void ToRgba32(ref Rgba32 dest)
-    {
-        dest.R = this.R;
-        dest.G = this.G;
-        dest.B = this.B;
-        dest.A = this.A;
-    }
+    /// <inheritdoc/>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Argb32 FromRgba32(Rgba32 source) => new(source.R, source.G, source.B, source.A);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgb48(Rgb48 source)
-    {
-        this.R = ColorNumerics.DownScaleFrom16BitTo8Bit(source.R);
-        this.G = ColorNumerics.DownScaleFrom16BitTo8Bit(source.G);
-        this.B = ColorNumerics.DownScaleFrom16BitTo8Bit(source.B);
-        this.A = byte.MaxValue;
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Argb32 FromRgb48(Rgb48 source)
+        => new()
+        {
+            R = ColorNumerics.From16BitTo8Bit(source.R),
+            G = ColorNumerics.From16BitTo8Bit(source.G),
+            B = ColorNumerics.From16BitTo8Bit(source.B),
+            A = byte.MaxValue
+        };
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgba64(Rgba64 source)
-    {
-        this.R = ColorNumerics.DownScaleFrom16BitTo8Bit(source.R);
-        this.G = ColorNumerics.DownScaleFrom16BitTo8Bit(source.G);
-        this.B = ColorNumerics.DownScaleFrom16BitTo8Bit(source.B);
-        this.A = ColorNumerics.DownScaleFrom16BitTo8Bit(source.A);
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Argb32 FromRgba64(Rgba64 source)
+        => new()
+        {
+            R = ColorNumerics.From16BitTo8Bit(source.R),
+            G = ColorNumerics.From16BitTo8Bit(source.G),
+            B = ColorNumerics.From16BitTo8Bit(source.B),
+            A = ColorNumerics.From16BitTo8Bit(source.A)
+        };
 
     /// <inheritdoc/>
     public override readonly bool Equals(object? obj) => obj is Argb32 argb32 && this.Equals(argb32);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
     public readonly bool Equals(Argb32 other) => this.Argb == other.Argb;
 
     /// <summary>
@@ -346,48 +282,20 @@ public partial struct Argb32 : IPixel<Argb32>, IPackedVector<uint>
     public override readonly string ToString() => $"Argb({this.A}, {this.R}, {this.G}, {this.B})";
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
     public override readonly int GetHashCode() => this.Argb.GetHashCode();
 
-    /// <summary>
-    /// Packs the four floats into a color.
-    /// </summary>
-    /// <param name="x">The x-component</param>
-    /// <param name="y">The y-component</param>
-    /// <param name="z">The z-component</param>
-    /// <param name="w">The w-component</param>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    private void Pack(float x, float y, float z, float w)
-    {
-        var value = new Vector4(x, y, z, w);
-        this.Pack(ref value);
-    }
-
-    /// <summary>
-    /// Packs a <see cref="Vector3"/> into a uint.
-    /// </summary>
-    /// <param name="vector">The vector containing the values to pack.</param>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    private void Pack(ref Vector3 vector)
-    {
-        var value = new Vector4(vector, 1);
-        this.Pack(ref value);
-    }
-
     /// <summary>
     /// Packs a <see cref="Vector4"/> into a color.
     /// </summary>
     /// <param name="vector">The vector containing the values to pack.</param>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    private void Pack(ref Vector4 vector)
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static Argb32 Pack(Vector4 vector)
     {
         vector *= MaxBytes;
         vector += Half;
         vector = Numerics.Clamp(vector, Vector4.Zero, MaxBytes);
 
-        this.R = (byte)vector.X;
-        this.G = (byte)vector.Y;
-        this.B = (byte)vector.Z;
-        this.A = (byte)vector.W;
+        Vector128<byte> result = Vector128.ConvertToInt32(vector.AsVector128()).AsByte();
+        return new(result.GetElement(0), result.GetElement(4), result.GetElement(8), result.GetElement(12));
     }
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Bgr24.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Bgr24.cs
index aedf4ad19..a860edc56 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Bgr24.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Bgr24.cs
@@ -4,6 +4,7 @@
 using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics;
 
 namespace SixLabors.ImageSharp.PixelFormats;
 
@@ -35,13 +36,16 @@ public partial struct Bgr24 : IPixel<Bgr24>
     [FieldOffset(2)]
     public byte R;
 
+    private static readonly Vector4 MaxBytes = Vector128.Create(255f).AsVector4();
+    private static readonly Vector4 Half = Vector128.Create(.5f).AsVector4();
+
     /// <summary>
     /// Initializes a new instance of the <see cref="Bgr24"/> struct.
     /// </summary>
     /// <param name="r">The red component.</param>
     /// <param name="g">The green component.</param>
     /// <param name="b">The blue component.</param>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public Bgr24(byte r, byte g, byte b)
     {
         this.R = r;
@@ -49,22 +53,6 @@ public partial struct Bgr24 : IPixel<Bgr24>
         this.B = b;
     }
 
-    /// <summary>
-    /// Converts an <see cref="Bgr24"/> to <see cref="Color"/>.
-    /// </summary>
-    /// <param name="source">The <see cref="Bgr24"/>.</param>
-    /// <returns>The <see cref="Color"/>.</returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public static implicit operator Color(Bgr24 source) => new(source);
-
-    /// <summary>
-    /// Converts a <see cref="Color"/> to <see cref="Bgr24"/>.
-    /// </summary>
-    /// <param name="color">The <see cref="Color"/>.</param>
-    /// <returns>The <see cref="Bgr24"/>.</returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public static implicit operator Bgr24(Color color) => color.ToBgr24();
-
     /// <summary>
     /// Compares two <see cref="Bgr24"/> objects for equality.
     /// </summary>
@@ -73,7 +61,7 @@ public partial struct Bgr24 : IPixel<Bgr24>
     /// <returns>
     /// True if the <paramref name="left"/> parameter is equal to the <paramref name="right"/> parameter; otherwise, false.
     /// </returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator ==(Bgr24 left, Bgr24 right) => left.Equals(right);
 
     /// <summary>
@@ -84,150 +72,120 @@ public partial struct Bgr24 : IPixel<Bgr24>
     /// <returns>
     /// True if the <paramref name="left"/> parameter is not equal to the <paramref name="right"/> parameter; otherwise, false.
     /// </returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator !=(Bgr24 left, Bgr24 right) => !left.Equals(right);
 
-    /// <inheritdoc/>
-    public readonly PixelOperations<Bgr24> CreatePixelOperations() => new PixelOperations();
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly Rgba32 ToRgba32() => Rgba32.FromBgr24(this);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromScaledVector4(Vector4 vector) => this.FromVector4(vector);
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly Vector4 ToScaledVector4() => this.ToVector4();
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public readonly Vector4 ToScaledVector4() => this.ToVector4();
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly Vector4 ToVector4() => new Vector4(this.R, this.G, this.B, byte.MaxValue) / MaxBytes;
+
+    /// <inheritdoc />
+    public static PixelTypeInfo GetPixelTypeInfo()
+        => PixelTypeInfo.Create<Bgr24>(
+            PixelComponentInfo.Create<Bgr24>(3, 8, 8, 8),
+            PixelColorType.BGR,
+            PixelAlphaRepresentation.None);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromVector4(Vector4 vector)
-    {
-        Rgba32 rgba = default;
-        rgba.FromVector4(vector);
-        this.FromRgba32(rgba);
-    }
+    public static PixelOperations<Bgr24> CreatePixelOperations() => new PixelOperations();
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public readonly Vector4 ToVector4() => new Rgba32(this.R, this.G, this.B, byte.MaxValue).ToVector4();
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Bgr24 FromScaledVector4(Vector4 source) => FromVector4(source);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromArgb32(Argb32 source)
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Bgr24 FromVector4(Vector4 source)
     {
-        this.R = source.R;
-        this.G = source.G;
-        this.B = source.B;
+        source *= MaxBytes;
+        source += Half;
+        source = Numerics.Clamp(source, Vector4.Zero, MaxBytes);
+
+        Vector128<byte> result = Vector128.ConvertToInt32(source.AsVector128()).AsByte();
+        return new(result.GetElement(0), result.GetElement(4), result.GetElement(8));
     }
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgr24(Bgr24 source) => this = source;
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Bgr24 FromAbgr32(Abgr32 source) => new(source.R, source.G, source.B);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgra5551(Bgra5551 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Bgr24 FromArgb32(Argb32 source) => new(source.R, source.G, source.B);
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgra32(Bgra32 source)
-    {
-        this.R = source.R;
-        this.G = source.G;
-        this.B = source.B;
-    }
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Bgr24 FromBgra5551(Bgra5551 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromL8(L8 source)
-    {
-        this.R = source.PackedValue;
-        this.G = source.PackedValue;
-        this.B = source.PackedValue;
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Bgr24 FromBgr24(Bgr24 source) => new(source.R, source.G, source.B);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromL16(L16 source)
-    {
-        byte rgb = ColorNumerics.DownScaleFrom16BitTo8Bit(source.PackedValue);
-        this.R = rgb;
-        this.G = rgb;
-        this.B = rgb;
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Bgr24 FromBgra32(Bgra32 source) => new(source.R, source.G, source.B);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromLa16(La16 source)
-    {
-        this.R = source.L;
-        this.G = source.L;
-        this.B = source.L;
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Bgr24 FromL8(L8 source) => new(source.PackedValue, source.PackedValue, source.PackedValue);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromLa32(La32 source)
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Bgr24 FromL16(L16 source)
     {
-        byte rgb = ColorNumerics.DownScaleFrom16BitTo8Bit(source.L);
-        this.R = rgb;
-        this.G = rgb;
-        this.B = rgb;
+        byte rgb = ColorNumerics.From16BitTo8Bit(source.PackedValue);
+        return new(rgb, rgb, rgb);
     }
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgb24(Rgb24 source)
-    {
-        this.R = source.R;
-        this.G = source.G;
-        this.B = source.B;
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Bgr24 FromLa16(La16 source) => new(source.L, source.L, source.L);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromAbgr32(Abgr32 source)
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Bgr24 FromLa32(La32 source)
     {
-        // We can assign this instances value directly to last three bytes of the Abgr32.
-        ref byte sourceRef = ref Unsafe.As<Abgr32, byte>(ref source);
-        ref byte sourceRefFromB = ref Unsafe.AddByteOffset(ref sourceRef, 1);
-        this = Unsafe.As<byte, Bgr24>(ref sourceRefFromB);
+        byte rgb = ColorNumerics.From16BitTo8Bit(source.L);
+        return new(rgb, rgb, rgb);
     }
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgba32(Rgba32 source) => this = source.Bgr;
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Bgr24 FromRgb24(Rgb24 source) => new(source.R, source.G, source.B);
 
-    /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void ToRgba32(ref Rgba32 dest)
-    {
-        dest.R = this.R;
-        dest.G = this.G;
-        dest.B = this.B;
-        dest.A = byte.MaxValue;
-    }
+    /// <inheritdoc/>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Bgr24 FromRgba32(Rgba32 source) => new(source.R, source.G, source.B);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgb48(Rgb48 source)
-    {
-        this.R = ColorNumerics.DownScaleFrom16BitTo8Bit(source.R);
-        this.G = ColorNumerics.DownScaleFrom16BitTo8Bit(source.G);
-        this.B = ColorNumerics.DownScaleFrom16BitTo8Bit(source.B);
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Bgr24 FromRgb48(Rgb48 source)
+        => new()
+        {
+            R = ColorNumerics.From16BitTo8Bit(source.R),
+            G = ColorNumerics.From16BitTo8Bit(source.G),
+            B = ColorNumerics.From16BitTo8Bit(source.B)
+        };
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgba64(Rgba64 source)
-    {
-        this.R = ColorNumerics.DownScaleFrom16BitTo8Bit(source.R);
-        this.G = ColorNumerics.DownScaleFrom16BitTo8Bit(source.G);
-        this.B = ColorNumerics.DownScaleFrom16BitTo8Bit(source.B);
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Bgr24 FromRgba64(Rgba64 source)
+        => new()
+        {
+            R = ColorNumerics.From16BitTo8Bit(source.R),
+            G = ColorNumerics.From16BitTo8Bit(source.G),
+            B = ColorNumerics.From16BitTo8Bit(source.B)
+        };
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
     public readonly bool Equals(Bgr24 other) => this.R.Equals(other.R) && this.G.Equals(other.G) && this.B.Equals(other.B);
 
     /// <inheritdoc/>
@@ -237,6 +195,5 @@ public partial struct Bgr24 : IPixel<Bgr24>
     public override readonly string ToString() => $"Bgr24({this.B}, {this.G}, {this.R})";
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
     public override readonly int GetHashCode() => HashCode.Combine(this.R, this.B, this.G);
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Bgr565.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Bgr565.cs
index ac3b6f829..87055bf22 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Bgr565.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Bgr565.cs
@@ -13,7 +13,13 @@ namespace SixLabors.ImageSharp.PixelFormats;
 /// Ranges from [0, 0, 0, 1] to [1, 1, 1, 1] in vector form.
 /// </para>
 /// </summary>
-public partial struct Bgr565 : IPixel<Bgr565>, IPackedVector<ushort>
+/// <remarks>
+/// Initializes a new instance of the <see cref="Bgr565"/> struct.
+/// </remarks>
+/// <param name="vector">
+/// The vector containing the components for the packed value.
+/// </param>
+public partial struct Bgr565(Vector3 vector) : IPixel<Bgr565>, IPackedVector<ushort>
 {
     /// <summary>
     /// Initializes a new instance of the <see cref="Bgr565"/> struct.
@@ -26,16 +32,8 @@ public partial struct Bgr565 : IPixel<Bgr565>, IPackedVector<ushort>
     {
     }
 
-    /// <summary>
-    /// Initializes a new instance of the <see cref="Bgr565"/> struct.
-    /// </summary>
-    /// <param name="vector">
-    /// The vector containing the components for the packed value.
-    /// </param>
-    public Bgr565(Vector3 vector) => this.PackedValue = Pack(ref vector);
-
     /// <inheritdoc/>
-    public ushort PackedValue { get; set; }
+    public ushort PackedValue { get; set; } = Pack(vector);
 
     /// <summary>
     /// Compares two <see cref="Bgr565"/> objects for equality.
@@ -45,7 +43,7 @@ public partial struct Bgr565 : IPixel<Bgr565>, IPackedVector<ushort>
     /// <returns>
     /// True if the <paramref name="left"/> parameter is equal to the <paramref name="right"/> parameter; otherwise, false.
     /// </returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator ==(Bgr565 left, Bgr565 right) => left.Equals(right);
 
     /// <summary>
@@ -56,94 +54,96 @@ public partial struct Bgr565 : IPixel<Bgr565>, IPackedVector<ushort>
     /// <returns>
     /// True if the <paramref name="left"/> parameter is not equal to the <paramref name="right"/> parameter; otherwise, false.
     /// </returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator !=(Bgr565 left, Bgr565 right) => !left.Equals(right);
 
-    /// <inheritdoc />
-    public readonly PixelOperations<Bgr565> CreatePixelOperations() => new PixelOperations();
-
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromScaledVector4(Vector4 vector) => this.FromVector4(vector);
-
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public readonly Vector4 ToScaledVector4() => this.ToVector4();
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromVector4(Vector4 vector)
-    {
-        var vector3 = new Vector3(vector.X, vector.Y, vector.Z);
-        this.PackedValue = Pack(ref vector3);
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly Vector4 ToVector4() => new(this.ToVector3(), 1F);
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public readonly Vector4 ToVector4() => new(this.ToVector3(), 1F);
+    public static PixelTypeInfo GetPixelTypeInfo()
+        => PixelTypeInfo.Create<Bgr565>(
+            PixelComponentInfo.Create<Bgr565>(3, 5, 6, 5),
+            PixelColorType.BGR,
+            PixelAlphaRepresentation.None);
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromArgb32(Argb32 source) => this.FromVector4(source.ToVector4());
+    /// <inheritdoc />
+    public static PixelOperations<Bgr565> CreatePixelOperations() => new PixelOperations();
+
+    /// <inheritdoc />
+    public readonly Rgba32 ToRgba32() => Rgba32.FromScaledVector4(this.ToScaledVector4());
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgra5551(Bgra5551 source) => this.FromVector4(source.ToVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Bgr565 FromScaledVector4(Vector4 source) => FromVector4(source);
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgr24(Bgr24 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Bgr565 FromVector4(Vector4 source) => new() { PackedValue = Pack(new Vector3(source.X, source.Y, source.Z)) };
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgra32(Bgra32 source) => this.FromVector4(source.ToVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Bgr565 FromAbgr32(Abgr32 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromAbgr32(Abgr32 source) => this.FromVector4(source.ToVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Bgr565 FromArgb32(Argb32 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromL8(L8 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Bgr565 FromBgra5551(Bgra5551 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromL16(L16 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Bgr565 FromBgr24(Bgr24 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromLa16(La16 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Bgr565 FromBgra32(Bgra32 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromLa32(La32 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Bgr565 FromL8(L8 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgb24(Rgb24 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Bgr565 FromL16(L16 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgba32(Rgba32 source) => this.FromVector4(source.ToVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Bgr565 FromLa16(La16 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void ToRgba32(ref Rgba32 dest) => dest.FromScaledVector4(this.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Bgr565 FromLa32(La32 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgb48(Rgb48 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Bgr565 FromRgb24(Rgb24 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgba64(Rgba64 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Bgr565 FromRgba32(Rgba32 source) => FromScaledVector4(source.ToScaledVector4());
+
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Bgr565 FromRgb48(Rgb48 source) => FromScaledVector4(source.ToScaledVector4());
+
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Bgr565 FromRgba64(Rgba64 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <summary>
     /// Expands the packed representation into a <see cref="Vector3"/>.
     /// The vector components are typically expanded in least to greatest significance order.
     /// </summary>
     /// <returns>The <see cref="Vector3"/>.</returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public readonly Vector3 ToVector3() => new(
                    ((this.PackedValue >> 11) & 0x1F) * (1F / 31F),
                    ((this.PackedValue >> 5) & 0x3F) * (1F / 63F),
@@ -153,22 +153,20 @@ public partial struct Bgr565 : IPixel<Bgr565>, IPackedVector<ushort>
     public override readonly bool Equals(object? obj) => obj is Bgr565 other && this.Equals(other);
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
     public readonly bool Equals(Bgr565 other) => this.PackedValue.Equals(other.PackedValue);
 
     /// <inheritdoc />
     public override readonly string ToString()
     {
-        var vector = this.ToVector3();
+        Vector3 vector = this.ToVector3();
         return FormattableString.Invariant($"Bgr565({vector.Z:#0.##}, {vector.Y:#0.##}, {vector.X:#0.##})");
     }
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
     public override readonly int GetHashCode() => this.PackedValue.GetHashCode();
 
-    [MethodImpl(InliningOptions.ShortMethod)]
-    private static ushort Pack(ref Vector3 vector)
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static ushort Pack(Vector3 vector)
     {
         vector = Vector3.Clamp(vector, Vector3.Zero, Vector3.One);
 
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Bgra32.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Bgra32.cs
index d7222f2ef..0fe7e4cc2 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Bgra32.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Bgra32.cs
@@ -4,6 +4,7 @@
 using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics;
 
 namespace SixLabors.ImageSharp.PixelFormats;
 
@@ -38,15 +39,8 @@ public partial struct Bgra32 : IPixel<Bgra32>, IPackedVector<uint>
     /// </summary>
     public byte A;
 
-    /// <summary>
-    /// The maximum byte value.
-    /// </summary>
-    private static readonly Vector4 MaxBytes = new(255);
-
-    /// <summary>
-    /// The half vector value.
-    /// </summary>
-    private static readonly Vector4 Half = new(0.5F);
+    private static readonly Vector4 MaxBytes = Vector128.Create(255f).AsVector4();
+    private static readonly Vector4 Half = Vector128.Create(.5f).AsVector4();
 
     /// <summary>
     /// Initializes a new instance of the <see cref="Bgra32"/> struct.
@@ -54,7 +48,7 @@ public partial struct Bgra32 : IPixel<Bgra32>, IPackedVector<uint>
     /// <param name="r">The red component.</param>
     /// <param name="g">The green component.</param>
     /// <param name="b">The blue component.</param>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public Bgra32(byte r, byte g, byte b)
     {
         this.R = r;
@@ -70,7 +64,7 @@ public partial struct Bgra32 : IPixel<Bgra32>, IPackedVector<uint>
     /// <param name="g">The green component.</param>
     /// <param name="b">The blue component.</param>
     /// <param name="a">The alpha component.</param>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public Bgra32(byte r, byte g, byte b, byte a)
     {
         this.R = r;
@@ -84,10 +78,10 @@ public partial struct Bgra32 : IPixel<Bgra32>, IPackedVector<uint>
     /// </summary>
     public uint Bgra
     {
-        [MethodImpl(InliningOptions.ShortMethod)]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         readonly get => Unsafe.As<Bgra32, uint>(ref Unsafe.AsRef(in this));
 
-        [MethodImpl(InliningOptions.ShortMethod)]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         set => Unsafe.As<Bgra32, uint>(ref this) = value;
     }
 
@@ -98,22 +92,6 @@ public partial struct Bgra32 : IPixel<Bgra32>, IPackedVector<uint>
         set => this.Bgra = value;
     }
 
-    /// <summary>
-    /// Converts an <see cref="Bgra32"/> to <see cref="Color"/>.
-    /// </summary>
-    /// <param name="source">The <see cref="Bgra32"/>.</param>
-    /// <returns>The <see cref="Color"/>.</returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public static implicit operator Color(Bgra32 source) => new(source);
-
-    /// <summary>
-    /// Converts a <see cref="Color"/> to <see cref="Bgra32"/>.
-    /// </summary>
-    /// <param name="color">The <see cref="Color"/>.</param>
-    /// <returns>The <see cref="Bgra32"/>.</returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public static implicit operator Bgra32(Color color) => color.ToBgra32();
-
     /// <summary>
     /// Compares two <see cref="Bgra32"/> objects for equality.
     /// </summary>
@@ -122,7 +100,7 @@ public partial struct Bgra32 : IPixel<Bgra32>, IPackedVector<uint>
     /// <returns>
     /// True if the <paramref name="left"/> parameter is equal to the <paramref name="right"/> parameter; otherwise, false.
     /// </returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator ==(Bgra32 left, Bgra32 right) => left.Equals(right);
 
     /// <summary>
@@ -133,157 +111,112 @@ public partial struct Bgra32 : IPixel<Bgra32>, IPackedVector<uint>
     /// <returns>
     /// True if the <paramref name="left"/> parameter is not equal to the <paramref name="right"/> parameter; otherwise, false.
     /// </returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator !=(Bgra32 left, Bgra32 right) => !left.Equals(right);
 
-    /// <inheritdoc/>
-    public readonly PixelOperations<Bgra32> CreatePixelOperations() => new PixelOperations();
-
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromScaledVector4(Vector4 vector) => this.FromVector4(vector);
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly Rgba32 ToRgba32() => Rgba32.FromBgra32(this);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public readonly Vector4 ToScaledVector4() => this.ToVector4();
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromVector4(Vector4 vector) => this.Pack(vector);
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly Vector4 ToVector4() => new Vector4(this.R, this.G, this.B, this.A) / MaxBytes;
+
+    /// <inheritdoc />
+    public static PixelTypeInfo GetPixelTypeInfo()
+        => PixelTypeInfo.Create<Bgra32>(
+            PixelComponentInfo.Create<Bgra32>(4, 8, 8, 8, 8),
+            PixelColorType.BGR | PixelColorType.Alpha,
+            PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public readonly Vector4 ToVector4() => new Vector4(this.R, this.G, this.B, this.A) / MaxBytes;
+    public static PixelOperations<Bgra32> CreatePixelOperations() => new PixelOperations();
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromArgb32(Argb32 source)
-    {
-        this.R = source.R;
-        this.G = source.G;
-        this.B = source.B;
-        this.A = source.A;
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Bgra32 FromScaledVector4(Vector4 source) => FromVector4(source);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromAbgr32(Abgr32 source)
-    {
-        this.R = source.R;
-        this.G = source.G;
-        this.B = source.B;
-        this.A = source.A;
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Bgra32 FromVector4(Vector4 source) => Pack(source);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgr24(Bgr24 source)
-    {
-        this.R = source.R;
-        this.G = source.G;
-        this.B = source.B;
-        this.A = byte.MaxValue;
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Bgra32 FromAbgr32(Abgr32 source) => new(source.R, source.G, source.B, source.A);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgra5551(Bgra5551 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Bgra32 FromArgb32(Argb32 source) => new(source.R, source.G, source.B, source.A);
+
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Bgra32 FromBgra5551(Bgra5551 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgra32(Bgra32 source) => this = source;
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Bgra32 FromBgr24(Bgr24 source) => new(source.R, source.G, source.B);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromL8(L8 source)
-    {
-        this.R = source.PackedValue;
-        this.G = source.PackedValue;
-        this.B = source.PackedValue;
-        this.A = byte.MaxValue;
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Bgra32 FromBgra32(Bgra32 source) => new() { PackedValue = source.PackedValue };
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromL16(L16 source)
-    {
-        byte rgb = ColorNumerics.DownScaleFrom16BitTo8Bit(source.PackedValue);
-        this.R = rgb;
-        this.G = rgb;
-        this.B = rgb;
-        this.A = byte.MaxValue;
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Bgra32 FromL8(L8 source) => new(source.PackedValue, source.PackedValue, source.PackedValue);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromLa16(La16 source)
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Bgra32 FromL16(L16 source)
     {
-        this.R = source.L;
-        this.G = source.L;
-        this.B = source.L;
-        this.A = source.A;
+        byte rgb = ColorNumerics.From16BitTo8Bit(source.PackedValue);
+        return new(rgb, rgb, rgb);
     }
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromLa32(La32 source)
-    {
-        byte rgb = ColorNumerics.DownScaleFrom16BitTo8Bit(source.L);
-        this.R = rgb;
-        this.G = rgb;
-        this.B = rgb;
-        this.A = ColorNumerics.DownScaleFrom16BitTo8Bit(source.A);
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Bgra32 FromLa16(La16 source) => new(source.L, source.L, source.L, source.A);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgba32(Rgba32 source)
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Bgra32 FromLa32(La32 source)
     {
-        this.R = source.R;
-        this.G = source.G;
-        this.B = source.B;
-        this.A = source.A;
+        byte rgb = ColorNumerics.From16BitTo8Bit(source.L);
+        return new(rgb, rgb, rgb, ColorNumerics.From16BitTo8Bit(source.A));
     }
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgb24(Rgb24 source)
-    {
-        this.R = source.R;
-        this.G = source.G;
-        this.B = source.B;
-        this.A = byte.MaxValue;
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Bgra32 FromRgb24(Rgb24 source) => new(source.R, source.G, source.B);
 
-    /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void ToRgba32(ref Rgba32 dest)
-    {
-        dest.R = this.R;
-        dest.G = this.G;
-        dest.B = this.B;
-        dest.A = this.A;
-    }
+    /// <inheritdoc/>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Bgra32 FromRgba32(Rgba32 source) => new(source.R, source.G, source.B, source.A);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgb48(Rgb48 source)
-    {
-        this.R = ColorNumerics.DownScaleFrom16BitTo8Bit(source.R);
-        this.G = ColorNumerics.DownScaleFrom16BitTo8Bit(source.G);
-        this.B = ColorNumerics.DownScaleFrom16BitTo8Bit(source.B);
-        this.A = byte.MaxValue;
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Bgra32 FromRgb48(Rgb48 source)
+        => new()
+        {
+            R = ColorNumerics.From16BitTo8Bit(source.R),
+            G = ColorNumerics.From16BitTo8Bit(source.G),
+            B = ColorNumerics.From16BitTo8Bit(source.B),
+            A = byte.MaxValue
+        };
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgba64(Rgba64 source)
-    {
-        this.R = ColorNumerics.DownScaleFrom16BitTo8Bit(source.R);
-        this.G = ColorNumerics.DownScaleFrom16BitTo8Bit(source.G);
-        this.B = ColorNumerics.DownScaleFrom16BitTo8Bit(source.B);
-        this.A = ColorNumerics.DownScaleFrom16BitTo8Bit(source.A);
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Bgra32 FromRgba64(Rgba64 source)
+        => new()
+        {
+            R = ColorNumerics.From16BitTo8Bit(source.R),
+            G = ColorNumerics.From16BitTo8Bit(source.G),
+            B = ColorNumerics.From16BitTo8Bit(source.B),
+            A = ColorNumerics.From16BitTo8Bit(source.A)
+        };
 
     /// <inheritdoc/>
     public override readonly bool Equals(object? obj) => obj is Bgra32 other && this.Equals(other);
@@ -301,16 +234,14 @@ public partial struct Bgra32 : IPixel<Bgra32>, IPackedVector<uint>
     /// Packs a <see cref="Vector4"/> into a color.
     /// </summary>
     /// <param name="vector">The vector containing the values to pack.</param>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    private void Pack(Vector4 vector)
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static Bgra32 Pack(Vector4 vector)
     {
         vector *= MaxBytes;
         vector += Half;
         vector = Numerics.Clamp(vector, Vector4.Zero, MaxBytes);
 
-        this.R = (byte)vector.X;
-        this.G = (byte)vector.Y;
-        this.B = (byte)vector.Z;
-        this.A = (byte)vector.W;
+        Vector128<byte> result = Vector128.ConvertToInt32(vector.AsVector128()).AsByte();
+        return new(result.GetElement(0), result.GetElement(4), result.GetElement(8), result.GetElement(12));
     }
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Bgra4444.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Bgra4444.cs
index 8ba32c8ac..55971210c 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Bgra4444.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Bgra4444.cs
@@ -30,7 +30,7 @@ public partial struct Bgra4444 : IPixel<Bgra4444>, IPackedVector<ushort>
     /// Initializes a new instance of the <see cref="Bgra4444"/> struct.
     /// </summary>
     /// <param name="vector">The vector containing the components for the packed vector.</param>
-    public Bgra4444(Vector4 vector) => this.PackedValue = Pack(ref vector);
+    public Bgra4444(Vector4 vector) => this.PackedValue = Pack(vector);
 
     /// <inheritdoc/>
     public ushort PackedValue { get; set; }
@@ -43,7 +43,7 @@ public partial struct Bgra4444 : IPixel<Bgra4444>, IPackedVector<ushort>
     /// <returns>
     /// True if the <paramref name="left"/> parameter is equal to the <paramref name="right"/> parameter; otherwise, false.
     /// </returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator ==(Bgra4444 left, Bgra4444 right) => left.Equals(right);
 
     /// <summary>
@@ -54,113 +54,118 @@ public partial struct Bgra4444 : IPixel<Bgra4444>, IPackedVector<ushort>
     /// <returns>
     /// True if the <paramref name="left"/> parameter is not equal to the <paramref name="right"/> parameter; otherwise, false.
     /// </returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator !=(Bgra4444 left, Bgra4444 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public readonly PixelOperations<Bgra4444> CreatePixelOperations() => new PixelOperations();
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly Rgba32 ToRgba32() => Rgba32.FromScaledVector4(this.ToScaledVector4());
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromScaledVector4(Vector4 vector) => this.FromVector4(vector);
-
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public readonly Vector4 ToScaledVector4() => this.ToVector4();
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromVector4(Vector4 vector) => this.PackedValue = Pack(ref vector);
-
-    /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public readonly Vector4 ToVector4()
     {
-        const float Max = 1 / 15F;
+        const float max = 1 / 15f;
 
         return new Vector4(
             (this.PackedValue >> 8) & 0x0F,
             (this.PackedValue >> 4) & 0x0F,
             this.PackedValue & 0x0F,
-            (this.PackedValue >> 12) & 0x0F) * Max;
+            (this.PackedValue >> 12) & 0x0F) * max;
     }
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromArgb32(Argb32 source) => this.FromScaledVector4(source.ToScaledVector4());
+    public static PixelTypeInfo GetPixelTypeInfo()
+        => PixelTypeInfo.Create<Bgra4444>(
+            PixelComponentInfo.Create<Bgra4444>(4, 4, 4, 4, 4),
+            PixelColorType.BGR | PixelColorType.Alpha,
+            PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgra5551(Bgra5551 source) => this.FromScaledVector4(source.ToScaledVector4());
+    public static PixelOperations<Bgra4444> CreatePixelOperations() => new PixelOperations();
+
+    /// <inheritdoc/>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Bgra4444 FromScaledVector4(Vector4 source) => FromVector4(source);
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgr24(Bgr24 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Bgra4444 FromVector4(Vector4 source) => new() { PackedValue = Pack(source) };
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgra32(Bgra32 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Bgra4444 FromAbgr32(Abgr32 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromAbgr32(Abgr32 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Bgra4444 FromArgb32(Argb32 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromL8(L8 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Bgra4444 FromBgra5551(Bgra5551 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromL16(L16 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Bgra4444 FromBgr24(Bgr24 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromLa16(La16 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Bgra4444 FromBgra32(Bgra32 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromLa32(La32 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Bgra4444 FromL8(L8 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgb24(Rgb24 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Bgra4444 FromL16(L16 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgba32(Rgba32 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Bgra4444 FromLa16(La16 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void ToRgba32(ref Rgba32 dest) => dest.FromScaledVector4(this.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Bgra4444 FromLa32(La32 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgb48(Rgb48 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Bgra4444 FromRgb24(Rgb24 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgba64(Rgba64 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Bgra4444 FromRgba32(Rgba32 source) => FromScaledVector4(source.ToScaledVector4());
+
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Bgra4444 FromRgb48(Rgb48 source) => FromScaledVector4(source.ToScaledVector4());
+
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Bgra4444 FromRgba64(Rgba64 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc />
     public override readonly bool Equals(object? obj) => obj is Bgra4444 other && this.Equals(other);
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
     public readonly bool Equals(Bgra4444 other) => this.PackedValue.Equals(other.PackedValue);
 
     /// <inheritdoc />
     public override readonly string ToString()
     {
-        var vector = this.ToVector4();
+        Vector4 vector = this.ToVector4();
         return FormattableString.Invariant($"Bgra4444({vector.Z:#0.##}, {vector.Y:#0.##}, {vector.X:#0.##}, {vector.W:#0.##})");
     }
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
     public override readonly int GetHashCode() => this.PackedValue.GetHashCode();
 
-    [MethodImpl(InliningOptions.ShortMethod)]
-    private static ushort Pack(ref Vector4 vector)
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static ushort Pack(Vector4 vector)
     {
         vector = Numerics.Clamp(vector, Vector4.Zero, Vector4.One);
         return (ushort)((((int)Math.Round(vector.W * 15F) & 0x0F) << 12)
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Bgra5551.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Bgra5551.cs
index c282f03d8..4c94dea5f 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Bgra5551.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Bgra5551.cs
@@ -33,7 +33,7 @@ public partial struct Bgra5551 : IPixel<Bgra5551>, IPackedVector<ushort>
     /// <param name="vector">
     /// The vector containing the components for the packed vector.
     /// </param>
-    public Bgra5551(Vector4 vector) => this.PackedValue = Pack(ref vector);
+    public Bgra5551(Vector4 vector) => this.PackedValue = Pack(vector);
 
     /// <inheritdoc/>
     public ushort PackedValue { get; set; }
@@ -46,7 +46,7 @@ public partial struct Bgra5551 : IPixel<Bgra5551>, IPackedVector<ushort>
     /// <returns>
     /// True if the <paramref name="left"/> parameter is equal to the <paramref name="right"/> parameter; otherwise, false.
     /// </returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator ==(Bgra5551 left, Bgra5551 right) => left.Equals(right);
 
     /// <summary>
@@ -57,26 +57,19 @@ public partial struct Bgra5551 : IPixel<Bgra5551>, IPackedVector<ushort>
     /// <returns>
     /// True if the <paramref name="left"/> parameter is not equal to the <paramref name="right"/> parameter; otherwise, false.
     /// </returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator !=(Bgra5551 left, Bgra5551 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public readonly PixelOperations<Bgra5551> CreatePixelOperations() => new PixelOperations();
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly Rgba32 ToRgba32() => Rgba32.FromScaledVector4(this.ToScaledVector4());
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromScaledVector4(Vector4 vector) => this.FromVector4(vector);
-
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public readonly Vector4 ToScaledVector4() => this.ToVector4();
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromVector4(Vector4 vector) => this.PackedValue = Pack(ref vector);
-
-    /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public readonly Vector4 ToVector4() => new(
                     ((this.PackedValue >> 10) & 0x1F) / 31F,
                     ((this.PackedValue >> 5) & 0x1F) / 31F,
@@ -84,81 +77,93 @@ public partial struct Bgra5551 : IPixel<Bgra5551>, IPackedVector<ushort>
                     (this.PackedValue >> 15) & 0x01);
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgra5551(Bgra5551 source) => this = source;
+    public static PixelTypeInfo GetPixelTypeInfo()
+        => PixelTypeInfo.Create<Bgra5551>(
+            PixelComponentInfo.Create<Bgra5551>(4, 5, 5, 5, 1),
+            PixelColorType.BGR | PixelColorType.Alpha,
+            PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromArgb32(Argb32 source) => this.FromScaledVector4(source.ToScaledVector4());
+    public static PixelOperations<Bgra5551> CreatePixelOperations() => new PixelOperations();
+
+    /// <inheritdoc/>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Bgra5551 FromScaledVector4(Vector4 source) => FromVector4(source);
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgr24(Bgr24 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Bgra5551 FromVector4(Vector4 source) => new() { PackedValue = Pack(source) };
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgra32(Bgra32 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Bgra5551 FromAbgr32(Abgr32 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromL8(L8 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Bgra5551 FromArgb32(Argb32 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromL16(L16 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Bgra5551 FromBgra5551(Bgra5551 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromLa16(La16 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Bgra5551 FromBgr24(Bgr24 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromLa32(La32 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Bgra5551 FromBgra32(Bgra32 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgb24(Rgb24 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Bgra5551 FromL8(L8 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgba32(Rgba32 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Bgra5551 FromL16(L16 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromAbgr32(Abgr32 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Bgra5551 FromLa16(La16 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void ToRgba32(ref Rgba32 dest) => dest.FromScaledVector4(this.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Bgra5551 FromLa32(La32 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgb48(Rgb48 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Bgra5551 FromRgb24(Rgb24 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgba64(Rgba64 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Bgra5551 FromRgba32(Rgba32 source) => FromScaledVector4(source.ToScaledVector4());
+
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Bgra5551 FromRgb48(Rgb48 source) => FromScaledVector4(source.ToScaledVector4());
+
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Bgra5551 FromRgba64(Rgba64 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc />
-    public override bool Equals(object? obj) => obj is Bgra5551 other && this.Equals(other);
+    public override readonly bool Equals(object? obj) => obj is Bgra5551 other && this.Equals(other);
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
     public readonly bool Equals(Bgra5551 other) => this.PackedValue.Equals(other.PackedValue);
 
     /// <inheritdoc />
     public override readonly string ToString()
     {
-        var vector = this.ToVector4();
+        Vector4 vector = this.ToVector4();
         return FormattableString.Invariant($"Bgra5551({vector.Z:#0.##}, {vector.Y:#0.##}, {vector.X:#0.##}, {vector.W:#0.##})");
     }
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
     public override readonly int GetHashCode() => this.PackedValue.GetHashCode();
 
-    [MethodImpl(InliningOptions.ShortMethod)]
-    private static ushort Pack(ref Vector4 vector)
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static ushort Pack(Vector4 vector)
     {
         vector = Numerics.Clamp(vector, Vector4.Zero, Vector4.One);
         return (ushort)(
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Byte4.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Byte4.cs
index e699e5fe5..680a7ee0b 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Byte4.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Byte4.cs
@@ -3,6 +3,7 @@
 
 using System.Numerics;
 using System.Runtime.CompilerServices;
+using System.Runtime.Intrinsics;
 
 namespace SixLabors.ImageSharp.PixelFormats;
 
@@ -14,13 +15,7 @@ namespace SixLabors.ImageSharp.PixelFormats;
 /// </summary>
 public partial struct Byte4 : IPixel<Byte4>, IPackedVector<uint>
 {
-    /// <summary>
-    /// Initializes a new instance of the <see cref="Byte4"/> struct.
-    /// </summary>
-    /// <param name="vector">
-    /// A vector containing the initial values for the components of the Byte4 structure.
-    /// </param>
-    public Byte4(Vector4 vector) => this.PackedValue = Pack(ref vector);
+    private static readonly Vector4 MaxBytes = Vector128.Create(255f).AsVector4();
 
     /// <summary>
     /// Initializes a new instance of the <see cref="Byte4"/> struct.
@@ -30,11 +25,18 @@ public partial struct Byte4 : IPixel<Byte4>, IPackedVector<uint>
     /// <param name="z">The z-component</param>
     /// <param name="w">The w-component</param>
     public Byte4(float x, float y, float z, float w)
+        : this(new Vector4(x, y, z, w))
     {
-        var vector = new Vector4(x, y, z, w);
-        this.PackedValue = Pack(ref vector);
     }
 
+    /// <summary>
+    /// Initializes a new instance of the <see cref="Byte4"/> struct.
+    /// </summary>
+    /// <param name="vector">
+    /// A vector containing the initial values for the components of the Byte4 structure.
+    /// </param>
+    public Byte4(Vector4 vector) => this.PackedValue = Pack(vector);
+
     /// <inheritdoc/>
     public uint PackedValue { get; set; }
 
@@ -46,7 +48,7 @@ public partial struct Byte4 : IPixel<Byte4>, IPackedVector<uint>
     /// <returns>
     /// True if the <paramref name="left"/> parameter is equal to the <paramref name="right"/> parameter; otherwise, false.
     /// </returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator ==(Byte4 left, Byte4 right) => left.Equals(right);
 
     /// <summary>
@@ -57,103 +59,108 @@ public partial struct Byte4 : IPixel<Byte4>, IPackedVector<uint>
     /// <returns>
     /// True if the <paramref name="left"/> parameter is not equal to the <paramref name="right"/> parameter; otherwise, false.
     /// </returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator !=(Byte4 left, Byte4 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public readonly PixelOperations<Byte4> CreatePixelOperations() => new PixelOperations();
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public Rgba32 ToRgba32() => new() { PackedValue = this.PackedValue };
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromScaledVector4(Vector4 vector) => this.FromVector4(vector * 255F);
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly Vector4 ToScaledVector4() => this.ToVector4() / 255f;
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public readonly Vector4 ToScaledVector4() => this.ToVector4() / 255F;
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly Vector4 ToVector4() => new(
+            this.PackedValue & 0xFF,
+            (this.PackedValue >> 8) & 0xFF,
+            (this.PackedValue >> 16) & 0xFF,
+            (this.PackedValue >> 24) & 0xFF);
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromVector4(Vector4 vector) => this.PackedValue = Pack(ref vector);
+    public static PixelTypeInfo GetPixelTypeInfo()
+        => PixelTypeInfo.Create<Byte4>(
+            PixelComponentInfo.Create<Byte4>(4, 8, 8, 8, 8),
+            PixelColorType.RGB | PixelColorType.Alpha,
+            PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public readonly Vector4 ToVector4() => new(
-            this.PackedValue & 0xFF,
-            (this.PackedValue >> 0x8) & 0xFF,
-            (this.PackedValue >> 0x10) & 0xFF,
-            (this.PackedValue >> 0x18) & 0xFF);
+    public static PixelOperations<Byte4> CreatePixelOperations() => new PixelOperations();
+
+    /// <inheritdoc/>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Byte4 FromScaledVector4(Vector4 source) => FromVector4(source * 255f);
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromArgb32(Argb32 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Byte4 FromVector4(Vector4 source) => new() { PackedValue = Pack(source) };
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgr24(Bgr24 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Byte4 FromAbgr32(Abgr32 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgra32(Bgra32 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Byte4 FromArgb32(Argb32 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromL8(L8 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Byte4 FromBgra5551(Bgra5551 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromL16(L16 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Byte4 FromBgr24(Bgr24 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromLa16(La16 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Byte4 FromBgra32(Bgra32 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromLa32(La32 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Byte4 FromL8(L8 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgb24(Rgb24 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Byte4 FromL16(L16 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgra5551(Bgra5551 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Byte4 FromLa16(La16 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgba32(Rgba32 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Byte4 FromLa32(La32 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromAbgr32(Abgr32 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Byte4 FromRgb24(Rgb24 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void ToRgba32(ref Rgba32 dest) => dest.FromScaledVector4(this.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Byte4 FromRgba32(Rgba32 source) => new() { PackedValue = source.PackedValue };
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgb48(Rgb48 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Byte4 FromRgb48(Rgb48 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgba64(Rgba64 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Byte4 FromRgba64(Rgba64 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc />
     public override readonly bool Equals(object? obj) => obj is Byte4 byte4 && this.Equals(byte4);
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
     public readonly bool Equals(Byte4 other) => this.PackedValue.Equals(other.PackedValue);
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
     public override readonly int GetHashCode() => this.PackedValue.GetHashCode();
 
     /// <inheritdoc />
     public override readonly string ToString()
     {
-        var vector = this.ToVector4();
+        Vector4 vector = this.ToVector4();
         return FormattableString.Invariant($"Byte4({vector.X:#0.##}, {vector.Y:#0.##}, {vector.Z:#0.##}, {vector.W:#0.##})");
     }
 
@@ -162,13 +169,10 @@ public partial struct Byte4 : IPixel<Byte4>, IPackedVector<uint>
     /// </summary>
     /// <param name="vector">The vector containing the values to pack.</param>
     /// <returns>The <see cref="uint"/> containing the packed values.</returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    private static uint Pack(ref Vector4 vector)
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static uint Pack(Vector4 vector)
     {
-        const float Max = 255F;
-
-        // Clamp the value between min and max values
-        vector = Numerics.Clamp(vector, Vector4.Zero, new Vector4(Max));
+        vector = Numerics.Clamp(vector, Vector4.Zero, MaxBytes);
 
         uint byte4 = (uint)Math.Round(vector.X) & 0xFF;
         uint byte3 = ((uint)Math.Round(vector.Y) & 0xFF) << 0x8;
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/HalfSingle.cs b/src/ImageSharp/PixelFormats/PixelImplementations/HalfSingle.cs
index db1e02adc..888d992d8 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/HalfSingle.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/HalfSingle.cs
@@ -31,7 +31,7 @@ public partial struct HalfSingle : IPixel<HalfSingle>, IPackedVector<ushort>
     /// <returns>
     /// True if the <paramref name="left"/> parameter is equal to the <paramref name="right"/> parameter; otherwise, false.
     /// </returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator ==(HalfSingle left, HalfSingle right) => left.Equals(right);
 
     /// <summary>
@@ -42,24 +42,15 @@ public partial struct HalfSingle : IPixel<HalfSingle>, IPackedVector<ushort>
     /// <returns>
     /// True if the <paramref name="left"/> parameter is not equal to the <paramref name="right"/> parameter; otherwise, false.
     /// </returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator !=(HalfSingle left, HalfSingle right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public PixelOperations<HalfSingle> CreatePixelOperations() => new PixelOperations();
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly Rgba32 ToRgba32() => Rgba32.FromScaledVector4(this.ToScaledVector4());
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromScaledVector4(Vector4 vector)
-    {
-        float scaled = vector.X;
-        scaled *= 2F;
-        scaled--;
-        this.PackedValue = HalfTypeHelper.Pack(scaled);
-    }
-
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public readonly Vector4 ToScaledVector4()
     {
         float single = this.ToSingle() + 1F;
@@ -68,87 +59,101 @@ public partial struct HalfSingle : IPixel<HalfSingle>, IPackedVector<ushort>
     }
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromVector4(Vector4 vector) => this.PackedValue = HalfTypeHelper.Pack(vector.X);
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly Vector4 ToVector4() => new(this.ToSingle(), 0, 0, 1F);
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public readonly Vector4 ToVector4() => new(this.ToSingle(), 0, 0, 1F);
+    public static PixelTypeInfo GetPixelTypeInfo()
+        => PixelTypeInfo.Create<HalfSingle>(
+            PixelComponentInfo.Create<HalfSingle>(1, 16),
+            PixelColorType.Red,
+            PixelAlphaRepresentation.None);
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromArgb32(Argb32 source) => this.FromScaledVector4(source.ToScaledVector4());
+    public static PixelOperations<HalfSingle> CreatePixelOperations() => new PixelOperations();
+
+    /// <inheritdoc/>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static HalfSingle FromScaledVector4(Vector4 source)
+    {
+        float scaled = source.X;
+        scaled *= 2F;
+        scaled--;
+        return new() { PackedValue = HalfTypeHelper.Pack(scaled) };
+    }
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgr24(Bgr24 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static HalfSingle FromVector4(Vector4 source) => new() { PackedValue = HalfTypeHelper.Pack(source.X) };
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgra32(Bgra32 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static HalfSingle FromAbgr32(Abgr32 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromAbgr32(Abgr32 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static HalfSingle FromArgb32(Argb32 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgra5551(Bgra5551 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static HalfSingle FromBgra5551(Bgra5551 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromL8(L8 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static HalfSingle FromBgr24(Bgr24 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromL16(L16 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static HalfSingle FromBgra32(Bgra32 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromLa16(La16 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static HalfSingle FromL8(L8 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromLa32(La32 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static HalfSingle FromL16(L16 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgb24(Rgb24 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static HalfSingle FromLa16(La16 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgba32(Rgba32 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static HalfSingle FromLa32(La32 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void ToRgba32(ref Rgba32 dest) => dest.FromScaledVector4(this.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static HalfSingle FromRgb24(Rgb24 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgb48(Rgb48 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static HalfSingle FromRgba32(Rgba32 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgba64(Rgba64 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static HalfSingle FromRgb48(Rgb48 source) => FromScaledVector4(source.ToScaledVector4());
+
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static HalfSingle FromRgba64(Rgba64 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <summary>
     /// Expands the packed representation into a <see cref="float"/>.
     /// </summary>
     /// <returns>The <see cref="float"/>.</returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public readonly float ToSingle() => HalfTypeHelper.Unpack(this.PackedValue);
 
     /// <inheritdoc />
     public override readonly bool Equals(object? obj) => obj is HalfSingle other && this.Equals(other);
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
     public readonly bool Equals(HalfSingle other) => this.PackedValue.Equals(other.PackedValue);
 
     /// <inheritdoc />
     public override readonly string ToString() => FormattableString.Invariant($"HalfSingle({this.ToSingle():#0.##})");
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
     public override readonly int GetHashCode() => this.PackedValue.GetHashCode();
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/HalfVector2.cs b/src/ImageSharp/PixelFormats/PixelImplementations/HalfVector2.cs
index 9caae58c9..861a8480a 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/HalfVector2.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/HalfVector2.cs
@@ -38,7 +38,7 @@ public partial struct HalfVector2 : IPixel<HalfVector2>, IPackedVector<uint>
     /// <returns>
     /// True if the <paramref name="left"/> parameter is equal to the <paramref name="right"/> parameter; otherwise, false.
     /// </returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator ==(HalfVector2 left, HalfVector2 right) => left.Equals(right);
 
     /// <summary>
@@ -49,104 +49,111 @@ public partial struct HalfVector2 : IPixel<HalfVector2>, IPackedVector<uint>
     /// <returns>
     /// True if the <paramref name="left"/> parameter is not equal to the <paramref name="right"/> parameter; otherwise, false.
     /// </returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator !=(HalfVector2 left, HalfVector2 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public readonly PixelOperations<HalfVector2> CreatePixelOperations() => new PixelOperations();
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly Rgba32 ToRgba32() => Rgba32.FromScaledVector4(this.ToScaledVector4());
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromScaledVector4(Vector4 vector)
-    {
-        Vector2 scaled = new Vector2(vector.X, vector.Y) * 2F;
-        scaled -= Vector2.One;
-        this.PackedValue = Pack(scaled.X, scaled.Y);
-    }
-
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public readonly Vector4 ToScaledVector4()
     {
-        var scaled = this.ToVector2();
+        Vector2 scaled = this.ToVector2();
         scaled += Vector2.One;
         scaled /= 2F;
-        return new Vector4(scaled, 0F, 1F);
+        return new(scaled, 0F, 1F);
+    }
+
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly Vector4 ToVector4()
+    {
+        Vector2 vector = this.ToVector2();
+        return new(vector.X, vector.Y, 0F, 1F);
     }
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromVector4(Vector4 vector) => this.PackedValue = Pack(vector.X, vector.Y);
+    public static PixelTypeInfo GetPixelTypeInfo()
+        => PixelTypeInfo.Create<HalfVector2>(
+            PixelComponentInfo.Create<HalfVector2>(2, 16, 16),
+            PixelColorType.Red | PixelColorType.Green,
+            PixelAlphaRepresentation.None);
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public readonly Vector4 ToVector4()
+    public static PixelOperations<HalfVector2> CreatePixelOperations() => new PixelOperations();
+
+    /// <inheritdoc/>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static HalfVector2 FromScaledVector4(Vector4 source)
     {
-        var vector = this.ToVector2();
-        return new Vector4(vector.X, vector.Y, 0F, 1F);
+        Vector2 scaled = new Vector2(source.X, source.Y) * 2F;
+        scaled -= Vector2.One;
+        return new() { PackedValue = Pack(scaled.X, scaled.Y) };
     }
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromArgb32(Argb32 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static HalfVector2 FromVector4(Vector4 source) => new() { PackedValue = Pack(source.X, source.Y) };
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgr24(Bgr24 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static HalfVector2 FromAbgr32(Abgr32 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgra32(Bgra32 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static HalfVector2 FromArgb32(Argb32 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromAbgr32(Abgr32 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static HalfVector2 FromBgra5551(Bgra5551 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgra5551(Bgra5551 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static HalfVector2 FromBgr24(Bgr24 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromL8(L8 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static HalfVector2 FromBgra32(Bgra32 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromL16(L16 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static HalfVector2 FromL8(L8 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromLa16(La16 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static HalfVector2 FromL16(L16 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromLa32(La32 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static HalfVector2 FromLa16(La16 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgb24(Rgb24 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static HalfVector2 FromLa32(La32 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgba32(Rgba32 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static HalfVector2 FromRgb24(Rgb24 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void ToRgba32(ref Rgba32 dest) => dest.FromScaledVector4(this.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static HalfVector2 FromRgba32(Rgba32 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgb48(Rgb48 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static HalfVector2 FromRgb48(Rgb48 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgba64(Rgba64 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static HalfVector2 FromRgba64(Rgba64 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <summary>
     /// Expands the packed representation into a <see cref="Vector2"/>.
     /// </summary>
     /// <returns>The <see cref="Vector2"/>.</returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public readonly Vector2 ToVector2()
     {
         Vector2 vector;
@@ -159,21 +166,19 @@ public partial struct HalfVector2 : IPixel<HalfVector2>, IPackedVector<uint>
     public override readonly bool Equals(object? obj) => obj is HalfVector2 other && this.Equals(other);
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
     public readonly bool Equals(HalfVector2 other) => this.PackedValue.Equals(other.PackedValue);
 
     /// <inheritdoc />
     public override readonly string ToString()
     {
-        var vector = this.ToVector2();
+        Vector2 vector = this.ToVector2();
         return FormattableString.Invariant($"HalfVector2({vector.X:#0.##}, {vector.Y:#0.##})");
     }
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
     public override readonly int GetHashCode() => this.PackedValue.GetHashCode();
 
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static uint Pack(float x, float y)
     {
         uint num2 = HalfTypeHelper.Pack(x);
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/HalfVector4.cs b/src/ImageSharp/PixelFormats/PixelImplementations/HalfVector4.cs
index 609fec3bd..d0b57d788 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/HalfVector4.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/HalfVector4.cs
@@ -30,7 +30,7 @@ public partial struct HalfVector4 : IPixel<HalfVector4>, IPackedVector<ulong>
     /// Initializes a new instance of the <see cref="HalfVector4"/> struct.
     /// </summary>
     /// <param name="vector">A vector containing the initial values for the components</param>
-    public HalfVector4(Vector4 vector) => this.PackedValue = Pack(ref vector);
+    public HalfVector4(Vector4 vector) => this.PackedValue = Pack(vector);
 
     /// <inheritdoc/>
     public ulong PackedValue { get; set; }
@@ -43,7 +43,7 @@ public partial struct HalfVector4 : IPixel<HalfVector4>, IPackedVector<ulong>
     /// <returns>
     /// True if the <paramref name="left"/> parameter is equal to the <paramref name="right"/> parameter; otherwise, false.
     /// </returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator ==(HalfVector4 left, HalfVector4 right) => left.Equals(right);
 
     /// <summary>
@@ -54,37 +54,25 @@ public partial struct HalfVector4 : IPixel<HalfVector4>, IPackedVector<ulong>
     /// <returns>
     /// True if the <paramref name="left"/> parameter is not equal to the <paramref name="right"/> parameter; otherwise, false.
     /// </returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator !=(HalfVector4 left, HalfVector4 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public readonly PixelOperations<HalfVector4> CreatePixelOperations() => new PixelOperations();
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly Rgba32 ToRgba32() => Rgba32.FromScaledVector4(this.ToScaledVector4());
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromScaledVector4(Vector4 vector)
-    {
-        vector *= 2F;
-        vector -= Vector4.One;
-        this.FromVector4(vector);
-    }
-
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public readonly Vector4 ToScaledVector4()
     {
-        var scaled = this.ToVector4();
+        Vector4 scaled = this.ToVector4();
         scaled += Vector4.One;
-        scaled /= 2F;
+        scaled /= 2f;
         return scaled;
     }
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromVector4(Vector4 vector) => this.PackedValue = Pack(ref vector);
-
-    /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public readonly Vector4 ToVector4() => new(
             HalfTypeHelper.Unpack((ushort)this.PackedValue),
             HalfTypeHelper.Unpack((ushort)(this.PackedValue >> 0x10)),
@@ -92,77 +80,94 @@ public partial struct HalfVector4 : IPixel<HalfVector4>, IPackedVector<ulong>
             HalfTypeHelper.Unpack((ushort)(this.PackedValue >> 0x30)));
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromArgb32(Argb32 source) => this.FromScaledVector4(source.ToScaledVector4());
+    public static PixelTypeInfo GetPixelTypeInfo()
+        => PixelTypeInfo.Create<HalfVector4>(
+            PixelComponentInfo.Create<HalfVector4>(4, 16, 16, 16, 16),
+            PixelColorType.RGB | PixelColorType.Alpha,
+            PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgr24(Bgr24 source) => this.FromScaledVector4(source.ToScaledVector4());
+    public static PixelOperations<HalfVector4> CreatePixelOperations() => new PixelOperations();
+
+    /// <inheritdoc/>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static HalfVector4 FromScaledVector4(Vector4 source)
+    {
+        source *= 2f;
+        source -= Vector4.One;
+        return FromVector4(source);
+    }
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgra32(Bgra32 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static HalfVector4 FromVector4(Vector4 source) => new() { PackedValue = Pack(source) };
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromAbgr32(Abgr32 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static HalfVector4 FromAbgr32(Abgr32 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgra5551(Bgra5551 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static HalfVector4 FromArgb32(Argb32 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromL8(L8 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static HalfVector4 FromBgra5551(Bgra5551 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromL16(L16 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static HalfVector4 FromBgr24(Bgr24 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromLa16(La16 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static HalfVector4 FromBgra32(Bgra32 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromLa32(La32 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static HalfVector4 FromL8(L8 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgb24(Rgb24 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static HalfVector4 FromL16(L16 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgba32(Rgba32 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static HalfVector4 FromLa16(La16 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void ToRgba32(ref Rgba32 dest) => dest.FromScaledVector4(this.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static HalfVector4 FromLa32(La32 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgb48(Rgb48 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static HalfVector4 FromRgb24(Rgb24 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgba64(Rgba64 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static HalfVector4 FromRgba32(Rgba32 source) => FromScaledVector4(source.ToScaledVector4());
+
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static HalfVector4 FromRgb48(Rgb48 source) => FromScaledVector4(source.ToScaledVector4());
+
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static HalfVector4 FromRgba64(Rgba64 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc />
     public override readonly bool Equals(object? obj) => obj is HalfVector4 other && this.Equals(other);
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
     public readonly bool Equals(HalfVector4 other) => this.PackedValue.Equals(other.PackedValue);
 
     /// <inheritdoc />
     public override readonly string ToString()
     {
-        var vector = this.ToVector4();
+        Vector4 vector = this.ToVector4();
         return FormattableString.Invariant($"HalfVector4({vector.X:#0.##}, {vector.Y:#0.##}, {vector.Z:#0.##}, {vector.W:#0.##})");
     }
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
     public override readonly int GetHashCode() => this.PackedValue.GetHashCode();
 
     /// <summary>
@@ -170,8 +175,8 @@ public partial struct HalfVector4 : IPixel<HalfVector4>, IPackedVector<ulong>
     /// </summary>
     /// <param name="vector">The vector containing the values to pack.</param>
     /// <returns>The <see cref="ulong"/> containing the packed values.</returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    private static ulong Pack(ref Vector4 vector)
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static ulong Pack(Vector4 vector)
     {
         ulong num4 = HalfTypeHelper.Pack(vector.X);
         ulong num3 = (ulong)HalfTypeHelper.Pack(vector.Y) << 0x10;
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/L16.cs b/src/ImageSharp/PixelFormats/PixelImplementations/L16.cs
index c6ee8744d..2b5241b0b 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/L16.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/L16.cs
@@ -33,7 +33,7 @@ public partial struct L16 : IPixel<L16>, IPackedVector<ushort>
     /// <returns>
     /// True if the <paramref name="left"/> parameter is equal to the <paramref name="right"/> parameter; otherwise, false.
     /// </returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator ==(L16 left, L16 right) => left.Equals(right);
 
     /// <summary>
@@ -44,134 +44,115 @@ public partial struct L16 : IPixel<L16>, IPackedVector<ushort>
     /// <returns>
     /// True if the <paramref name="left"/> parameter is not equal to the <paramref name="right"/> parameter; otherwise, false.
     /// </returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator !=(L16 left, L16 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public readonly PixelOperations<L16> CreatePixelOperations() => new PixelOperations();
-
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromScaledVector4(Vector4 vector) => this.ConvertFromRgbaScaledVector4(vector);
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly Rgba32 ToRgba32()
+    {
+        byte rgb = ColorNumerics.From16BitTo8Bit(this.PackedValue);
+        return new(rgb, rgb, rgb);
+    }
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public readonly Vector4 ToScaledVector4() => this.ToVector4();
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromVector4(Vector4 vector) => this.ConvertFromRgbaScaledVector4(vector);
-
-    /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public readonly Vector4 ToVector4()
     {
         float scaled = this.PackedValue / Max;
-        return new Vector4(scaled, scaled, scaled, 1F);
+        return new Vector4(scaled, scaled, scaled, 1f);
     }
 
+    /// <inheritdoc />
+    public static PixelTypeInfo GetPixelTypeInfo()
+        => PixelTypeInfo.Create<L16>(
+            PixelComponentInfo.Create<L16>(1, 16),
+            PixelColorType.Grayscale,
+            PixelAlphaRepresentation.None);
+
+    /// <inheritdoc />
+    public static PixelOperations<L16> CreatePixelOperations() => new PixelOperations();
+
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromArgb32(Argb32 source) => this.PackedValue = ColorNumerics.Get16BitBT709Luminance(
-            ColorNumerics.UpscaleFrom8BitTo16Bit(source.R),
-            ColorNumerics.UpscaleFrom8BitTo16Bit(source.G),
-            ColorNumerics.UpscaleFrom8BitTo16Bit(source.B));
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static L16 FromScaledVector4(Vector4 source) => FromVector4(source);
+
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static L16 FromVector4(Vector4 source) => new() { PackedValue = Pack(source) };
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgr24(Bgr24 source) => this.PackedValue = ColorNumerics.Get16BitBT709Luminance(
-            ColorNumerics.UpscaleFrom8BitTo16Bit(source.R),
-            ColorNumerics.UpscaleFrom8BitTo16Bit(source.G),
-            ColorNumerics.UpscaleFrom8BitTo16Bit(source.B));
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static L16 FromAbgr32(Abgr32 source) => new(ColorNumerics.Get16BitBT709Luminance(source.R, source.G, source.B));
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgra32(Bgra32 source) => this.PackedValue = ColorNumerics.Get16BitBT709Luminance(
-            ColorNumerics.UpscaleFrom8BitTo16Bit(source.R),
-            ColorNumerics.UpscaleFrom8BitTo16Bit(source.G),
-            ColorNumerics.UpscaleFrom8BitTo16Bit(source.B));
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static L16 FromArgb32(Argb32 source) => new(ColorNumerics.Get16BitBT709Luminance(source.R, source.G, source.B));
+
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static L16 FromBgra5551(Bgra5551 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromAbgr32(Abgr32 source) => this.PackedValue = ColorNumerics.Get16BitBT709Luminance(
-            ColorNumerics.UpscaleFrom8BitTo16Bit(source.R),
-            ColorNumerics.UpscaleFrom8BitTo16Bit(source.G),
-            ColorNumerics.UpscaleFrom8BitTo16Bit(source.B));
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static L16 FromBgr24(Bgr24 source) => new(ColorNumerics.Get16BitBT709Luminance(source.R, source.G, source.B));
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgra5551(Bgra5551 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static L16 FromBgra32(Bgra32 source) => new(ColorNumerics.Get16BitBT709Luminance(source.R, source.G, source.B));
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromL8(L8 source) => this.PackedValue = ColorNumerics.UpscaleFrom8BitTo16Bit(source.PackedValue);
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static L16 FromL8(L8 source) => new(ColorNumerics.From8BitTo16Bit(source.PackedValue));
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromL16(L16 source) => this = source;
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static L16 FromL16(L16 source) => new(source.PackedValue);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromLa16(La16 source) => this.PackedValue = ColorNumerics.UpscaleFrom8BitTo16Bit(source.L);
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static L16 FromLa16(La16 source) => new(ColorNumerics.From8BitTo16Bit(source.L));
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromLa32(La32 source) => this.PackedValue = source.L;
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static L16 FromLa32(La32 source) => new(source.L);
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgb24(Rgb24 source) => this.PackedValue = ColorNumerics.Get16BitBT709Luminance(
-            ColorNumerics.UpscaleFrom8BitTo16Bit(source.R),
-            ColorNumerics.UpscaleFrom8BitTo16Bit(source.G),
-            ColorNumerics.UpscaleFrom8BitTo16Bit(source.B));
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static L16 FromRgb24(Rgb24 source) => new(ColorNumerics.Get16BitBT709Luminance(source.R, source.G, source.B));
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgba32(Rgba32 source) => this.PackedValue = ColorNumerics.Get16BitBT709Luminance(
-            ColorNumerics.UpscaleFrom8BitTo16Bit(source.R),
-            ColorNumerics.UpscaleFrom8BitTo16Bit(source.G),
-            ColorNumerics.UpscaleFrom8BitTo16Bit(source.B));
-
-    /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void ToRgba32(ref Rgba32 dest)
-    {
-        byte rgb = ColorNumerics.DownScaleFrom16BitTo8Bit(this.PackedValue);
-        dest.R = rgb;
-        dest.G = rgb;
-        dest.B = rgb;
-        dest.A = byte.MaxValue;
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static L16 FromRgba32(Rgba32 source) => new(ColorNumerics.Get16BitBT709Luminance(source.R, source.G, source.B));
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgb48(Rgb48 source) => this.PackedValue = ColorNumerics.Get16BitBT709Luminance(source.R, source.G, source.B);
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static L16 FromRgb48(Rgb48 source) => new(ColorNumerics.Get16BitBT709Luminance(source.R, source.G, source.B));
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgba64(Rgba64 source) => this.PackedValue = ColorNumerics.Get16BitBT709Luminance(source.R, source.G, source.B);
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static L16 FromRgba64(Rgba64 source) => new(ColorNumerics.Get16BitBT709Luminance(source.R, source.G, source.B));
 
     /// <inheritdoc />
     public override readonly bool Equals(object? obj) => obj is L16 other && this.Equals(other);
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
     public readonly bool Equals(L16 other) => this.PackedValue.Equals(other.PackedValue);
 
     /// <inheritdoc />
     public override readonly string ToString() => $"L16({this.PackedValue})";
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
     public override readonly int GetHashCode() => this.PackedValue.GetHashCode();
 
-    [MethodImpl(InliningOptions.ShortMethod)]
-    internal void ConvertFromRgbaScaledVector4(Vector4 vector)
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static ushort Pack(Vector4 vector)
     {
         vector = Numerics.Clamp(vector, Vector4.Zero, Vector4.One) * Max;
-        this.PackedValue = ColorNumerics.Get16BitBT709Luminance(
-            vector.X,
-            vector.Y,
-            vector.Z);
+        return ColorNumerics.Get16BitBT709Luminance(vector.X, vector.Y, vector.Z);
     }
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/L8.cs b/src/ImageSharp/PixelFormats/PixelImplementations/L8.cs
index 383e09b27..5d733bdbb 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/L8.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/L8.cs
@@ -3,6 +3,7 @@
 
 using System.Numerics;
 using System.Runtime.CompilerServices;
+using System.Runtime.Intrinsics;
 
 namespace SixLabors.ImageSharp.PixelFormats;
 
@@ -14,8 +15,8 @@ namespace SixLabors.ImageSharp.PixelFormats;
 /// </summary>
 public partial struct L8 : IPixel<L8>, IPackedVector<byte>
 {
-    private static readonly Vector4 MaxBytes = new(255F);
-    private static readonly Vector4 Half = new(0.5F);
+    private static readonly Vector4 MaxBytes = Vector128.Create(255f).AsVector4();
+    private static readonly Vector4 Half = Vector128.Create(.5f).AsVector4();
 
     /// <summary>
     /// Initializes a new instance of the <see cref="L8"/> struct.
@@ -34,7 +35,7 @@ public partial struct L8 : IPixel<L8>, IPackedVector<byte>
     /// <returns>
     /// True if the <paramref name="left"/> parameter is equal to the <paramref name="right"/> parameter; otherwise, false.
     /// </returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator ==(L8 left, L8 right) => left.Equals(right);
 
     /// <summary>
@@ -45,122 +46,119 @@ public partial struct L8 : IPixel<L8>, IPackedVector<byte>
     /// <returns>
     /// True if the <paramref name="left"/> parameter is not equal to the <paramref name="right"/> parameter; otherwise, false.
     /// </returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator !=(L8 left, L8 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public readonly PixelOperations<L8> CreatePixelOperations() => new PixelOperations();
-
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromScaledVector4(Vector4 vector) => this.ConvertFromRgbaScaledVector4(vector);
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly Rgba32 ToRgba32()
+    {
+        byte rgb = this.PackedValue;
+        return new(rgb, rgb, rgb);
+    }
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public readonly Vector4 ToScaledVector4() => this.ToVector4();
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromVector4(Vector4 vector) => this.ConvertFromRgbaScaledVector4(vector);
-
-    /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public readonly Vector4 ToVector4()
     {
-        float rgb = this.PackedValue / 255F;
-        return new Vector4(rgb, rgb, rgb, 1F);
+        float rgb = this.PackedValue / 255f;
+        return new Vector4(rgb, rgb, rgb, 1f);
     }
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromArgb32(Argb32 source) => this.PackedValue = ColorNumerics.Get8BitBT709Luminance(source.R, source.G, source.B);
+    /// <inheritdoc />
+    public static PixelTypeInfo GetPixelTypeInfo()
+        => PixelTypeInfo.Create<L8>(
+            PixelComponentInfo.Create<L8>(1, 8),
+            PixelColorType.Grayscale,
+            PixelAlphaRepresentation.None);
+
+    /// <inheritdoc />
+    public static PixelOperations<L8> CreatePixelOperations() => new PixelOperations();
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgr24(Bgr24 source) => this.PackedValue = ColorNumerics.Get8BitBT709Luminance(source.R, source.G, source.B);
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static L8 FromScaledVector4(Vector4 source) => FromVector4(source);
+
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static L8 FromVector4(Vector4 source) => new() { PackedValue = Pack(source) };
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgra32(Bgra32 source) => this.PackedValue = ColorNumerics.Get8BitBT709Luminance(source.R, source.G, source.B);
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static L8 FromAbgr32(Abgr32 source) => new(ColorNumerics.Get8BitBT709Luminance(source.R, source.G, source.B));
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromAbgr32(Abgr32 source) => this.PackedValue = ColorNumerics.Get8BitBT709Luminance(source.R, source.G, source.B);
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static L8 FromArgb32(Argb32 source) => new(ColorNumerics.Get8BitBT709Luminance(source.R, source.G, source.B));
+
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static L8 FromBgra5551(Bgra5551 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgra5551(Bgra5551 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static L8 FromBgr24(Bgr24 source) => new(ColorNumerics.Get8BitBT709Luminance(source.R, source.G, source.B));
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromL8(L8 source) => this = source;
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static L8 FromBgra32(Bgra32 source) => new(ColorNumerics.Get8BitBT709Luminance(source.R, source.G, source.B));
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromL16(L16 source) => this.PackedValue = ColorNumerics.DownScaleFrom16BitTo8Bit(source.PackedValue);
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static L8 FromL8(L8 source) => new(source.PackedValue);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromLa16(La16 source) => this.PackedValue = source.L;
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static L8 FromL16(L16 source) => new(ColorNumerics.From16BitTo8Bit(source.PackedValue));
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromLa32(La32 source) => this.PackedValue = ColorNumerics.DownScaleFrom16BitTo8Bit(source.L);
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static L8 FromLa16(La16 source) => new(source.L);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgb24(Rgb24 source) => this.PackedValue = ColorNumerics.Get8BitBT709Luminance(source.R, source.G, source.B);
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static L8 FromLa32(La32 source) => new(ColorNumerics.From16BitTo8Bit(source.L));
 
-    /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgba32(Rgba32 source) => this.PackedValue = ColorNumerics.Get8BitBT709Luminance(source.R, source.G, source.B);
+    /// <inheritdoc/>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static L8 FromRgb24(Rgb24 source) => new(ColorNumerics.Get8BitBT709Luminance(source.R, source.G, source.B));
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void ToRgba32(ref Rgba32 dest)
-    {
-        dest.R = this.PackedValue;
-        dest.G = this.PackedValue;
-        dest.B = this.PackedValue;
-        dest.A = byte.MaxValue;
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static L8 FromRgba32(Rgba32 source) => new(ColorNumerics.Get8BitBT709Luminance(source.R, source.G, source.B));
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgb48(Rgb48 source)
-        => this.PackedValue = ColorNumerics.Get8BitBT709Luminance(
-            ColorNumerics.DownScaleFrom16BitTo8Bit(source.R),
-            ColorNumerics.DownScaleFrom16BitTo8Bit(source.G),
-            ColorNumerics.DownScaleFrom16BitTo8Bit(source.B));
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static L8 FromRgb48(Rgb48 source) => new(ColorNumerics.Get8BitBT709Luminance(source.R, source.G, source.B));
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgba64(Rgba64 source)
-        => this.PackedValue = ColorNumerics.Get8BitBT709Luminance(
-            ColorNumerics.DownScaleFrom16BitTo8Bit(source.R),
-            ColorNumerics.DownScaleFrom16BitTo8Bit(source.G),
-            ColorNumerics.DownScaleFrom16BitTo8Bit(source.B));
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static L8 FromRgba64(Rgba64 source) => new(ColorNumerics.Get8BitBT709Luminance(source.R, source.G, source.B));
 
     /// <inheritdoc />
     public override readonly bool Equals(object? obj) => obj is L8 other && this.Equals(other);
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
     public readonly bool Equals(L8 other) => this.PackedValue.Equals(other.PackedValue);
 
     /// <inheritdoc />
     public override readonly string ToString() => $"L8({this.PackedValue})";
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
     public override readonly int GetHashCode() => this.PackedValue.GetHashCode();
 
-    [MethodImpl(InliningOptions.ShortMethod)]
-    internal void ConvertFromRgbaScaledVector4(Vector4 vector)
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static byte Pack(Vector4 vector)
     {
         vector *= MaxBytes;
         vector += Half;
         vector = Numerics.Clamp(vector, Vector4.Zero, MaxBytes);
-        this.PackedValue = ColorNumerics.Get8BitBT709Luminance((byte)vector.X, (byte)vector.Y, (byte)vector.Z);
+
+        Vector128<byte> result = Vector128.ConvertToInt32(vector.AsVector128()).AsByte();
+        return ColorNumerics.Get8BitBT709Luminance(result.GetElement(0), result.GetElement(4), result.GetElement(8));
     }
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/La16.cs b/src/ImageSharp/PixelFormats/PixelImplementations/La16.cs
index 58aeb6189..69ca66218 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/La16.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/La16.cs
@@ -4,6 +4,7 @@
 using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics;
 
 namespace SixLabors.ImageSharp.PixelFormats;
 
@@ -16,8 +17,15 @@ namespace SixLabors.ImageSharp.PixelFormats;
 [StructLayout(LayoutKind.Explicit)]
 public partial struct La16 : IPixel<La16>, IPackedVector<ushort>
 {
-    private static readonly Vector4 MaxBytes = new(255F);
-    private static readonly Vector4 Half = new(0.5F);
+    /// <summary>
+    /// The maximum byte value.
+    /// </summary>
+    private static readonly Vector4 MaxBytes = Vector128.Create(255f).AsVector4();
+
+    /// <summary>
+    /// The half vector value.
+    /// </summary>
+    private static readonly Vector4 Half = Vector128.Create(.5f).AsVector4();
 
     /// <summary>
     /// Gets or sets the luminance component.
@@ -57,7 +65,7 @@ public partial struct La16 : IPixel<La16>, IPackedVector<ushort>
     /// <returns>
     /// True if the <paramref name="left"/> parameter is equal to the <paramref name="right"/> parameter; otherwise, false.
     /// </returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator ==(La16 left, La16 right) => left.Equals(right);
 
     /// <summary>
@@ -68,167 +76,118 @@ public partial struct La16 : IPixel<La16>, IPackedVector<ushort>
     /// <returns>
     /// True if the <paramref name="left"/> parameter is not equal to the <paramref name="right"/> parameter; otherwise, false.
     /// </returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator !=(La16 left, La16 right) => !left.Equals(right);
 
-    /// <inheritdoc/>
-    public readonly PixelOperations<La16> CreatePixelOperations() => new PixelOperations();
-
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public readonly bool Equals(La16 other) => this.PackedValue.Equals(other.PackedValue);
-
-    /// <inheritdoc />
-    public override readonly bool Equals(object? obj) => obj is La16 other && this.Equals(other);
-
     /// <inheritdoc />
-    public override readonly string ToString() => $"La16({this.L}, {this.A})";
-
-    /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public override readonly int GetHashCode() => this.PackedValue.GetHashCode();
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly Rgba32 ToRgba32() => new(this.L, this.L, this.L, this.A);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromArgb32(Argb32 source)
-    {
-        this.L = ColorNumerics.Get8BitBT709Luminance(source.R, source.G, source.B);
-        this.A = source.A;
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly Vector4 ToScaledVector4() => this.ToVector4();
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgr24(Bgr24 source)
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly Vector4 ToVector4()
     {
-        this.L = ColorNumerics.Get8BitBT709Luminance(source.R, source.G, source.B);
-        this.A = byte.MaxValue;
+        const float max = 255f;
+        float rgb = this.L / max;
+        return new Vector4(rgb, rgb, rgb, this.A / max);
     }
 
+    /// <inheritdoc />
+    public static PixelTypeInfo GetPixelTypeInfo()
+        => PixelTypeInfo.Create<La16>(
+            PixelComponentInfo.Create<La16>(2, 8, 8),
+            PixelColorType.Grayscale | PixelColorType.Alpha,
+            PixelAlphaRepresentation.Unassociated);
+
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgra32(Bgra32 source)
-    {
-        this.L = ColorNumerics.Get8BitBT709Luminance(source.R, source.G, source.B);
-        this.A = source.A;
-    }
+    public static PixelOperations<La16> CreatePixelOperations() => new PixelOperations();
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromAbgr32(Abgr32 source)
-    {
-        this.L = ColorNumerics.Get8BitBT709Luminance(source.R, source.G, source.B);
-        this.A = source.A;
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static La16 FromScaledVector4(Vector4 source) => Pack(source);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgra5551(Bgra5551 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static La16 FromVector4(Vector4 source) => Pack(source);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromL16(L16 source)
-    {
-        this.L = ColorNumerics.DownScaleFrom16BitTo8Bit(source.PackedValue);
-        this.A = byte.MaxValue;
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static La16 FromAbgr32(Abgr32 source) => new(ColorNumerics.Get8BitBT709Luminance(source.R, source.G, source.B), source.A);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromL8(L8 source)
-    {
-        this.L = source.PackedValue;
-        this.A = byte.MaxValue;
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static La16 FromArgb32(Argb32 source) => new(ColorNumerics.Get8BitBT709Luminance(source.R, source.G, source.B), source.A);
+
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static La16 FromBgra5551(Bgra5551 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromLa16(La16 source) => this = source;
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static La16 FromBgr24(Bgr24 source) => new(ColorNumerics.Get8BitBT709Luminance(source.R, source.G, source.B), byte.MaxValue);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromLa32(La32 source)
-    {
-        this.L = ColorNumerics.DownScaleFrom16BitTo8Bit(source.L);
-        this.A = ColorNumerics.DownScaleFrom16BitTo8Bit(source.A);
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static La16 FromBgra32(Bgra32 source) => new(ColorNumerics.Get8BitBT709Luminance(source.R, source.G, source.B), source.A);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgb24(Rgb24 source)
-    {
-        this.L = ColorNumerics.Get8BitBT709Luminance(source.R, source.G, source.B);
-        this.A = byte.MaxValue;
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static La16 FromL16(L16 source) => new(ColorNumerics.From16BitTo8Bit(source.PackedValue), byte.MaxValue);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgb48(Rgb48 source)
-    {
-        this.L = ColorNumerics.Get8BitBT709Luminance(
-            ColorNumerics.DownScaleFrom16BitTo8Bit(source.R),
-            ColorNumerics.DownScaleFrom16BitTo8Bit(source.G),
-            ColorNumerics.DownScaleFrom16BitTo8Bit(source.B));
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static La16 FromL8(L8 source) => new(source.PackedValue, byte.MaxValue);
 
-        this.A = byte.MaxValue;
-    }
+    /// <inheritdoc/>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static La16 FromLa16(La16 source) => new(source.L, source.A);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgba32(Rgba32 source)
-    {
-        this.L = ColorNumerics.Get8BitBT709Luminance(source.R, source.G, source.B);
-        this.A = source.A;
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static La16 FromLa32(La32 source) => new(ColorNumerics.From16BitTo8Bit(source.L), ColorNumerics.From16BitTo8Bit(source.A));
 
     /// <inheritdoc/>
-    public void FromRgba64(Rgba64 source)
-    {
-        this.L = ColorNumerics.Get8BitBT709Luminance(
-            ColorNumerics.DownScaleFrom16BitTo8Bit(source.R),
-            ColorNumerics.DownScaleFrom16BitTo8Bit(source.G),
-            ColorNumerics.DownScaleFrom16BitTo8Bit(source.B));
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static La16 FromRgb24(Rgb24 source) => new(ColorNumerics.Get8BitBT709Luminance(source.R, source.G, source.B), byte.MaxValue);
 
-        this.A = ColorNumerics.DownScaleFrom16BitTo8Bit(source.A);
-    }
+    /// <inheritdoc/>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static La16 FromRgba32(Rgba32 source) => new(ColorNumerics.Get8BitBT709Luminance(source.R, source.G, source.B), source.A);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromScaledVector4(Vector4 vector) => this.ConvertFromRgbaScaledVector4(vector);
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static La16 FromRgb48(Rgb48 source) => new(ColorNumerics.Get8BitBT709Luminance(source.R, source.G, source.B), byte.MaxValue);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromVector4(Vector4 vector) => this.ConvertFromRgbaScaledVector4(vector);
+    public static La16 FromRgba64(Rgba64 source) => new(ColorNumerics.Get8BitBT709Luminance(source.R, source.G, source.B), ColorNumerics.From16BitTo8Bit(source.A));
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void ToRgba32(ref Rgba32 dest)
-    {
-        dest.R = this.L;
-        dest.G = this.L;
-        dest.B = this.L;
-        dest.A = this.A;
-    }
+    public override readonly bool Equals(object? obj) => obj is La16 other && this.Equals(other);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public readonly Vector4 ToScaledVector4() => this.ToVector4();
+    public readonly bool Equals(La16 other) => this.PackedValue.Equals(other.PackedValue);
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public readonly Vector4 ToVector4()
-    {
-        const float Max = 255F;
-        float rgb = this.L / Max;
-        return new Vector4(rgb, rgb, rgb, this.A / Max);
-    }
+    /// <inheritdoc />
+    public override readonly string ToString() => $"La16({this.L}, {this.A})";
 
-    [MethodImpl(InliningOptions.ShortMethod)]
-    internal void ConvertFromRgbaScaledVector4(Vector4 vector)
+    /// <inheritdoc />
+    public override readonly int GetHashCode() => this.PackedValue.GetHashCode();
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static La16 Pack(Vector4 vector)
     {
         vector *= MaxBytes;
         vector += Half;
         vector = Numerics.Clamp(vector, Vector4.Zero, MaxBytes);
-        this.L = ColorNumerics.Get8BitBT709Luminance((byte)vector.X, (byte)vector.Y, (byte)vector.Z);
-        this.A = (byte)vector.W;
+
+        Vector128<byte> result = Vector128.ConvertToInt32(vector.AsVector128()).AsByte();
+        byte l = ColorNumerics.Get8BitBT709Luminance(result.GetElement(0), result.GetElement(4), result.GetElement(8));
+        byte a = result.GetElement(12);
+
+        return new(l, a);
     }
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/La32.cs b/src/ImageSharp/PixelFormats/PixelImplementations/La32.cs
index db7f43329..1886ef39a 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/La32.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/La32.cs
@@ -44,10 +44,10 @@ public partial struct La32 : IPixel<La32>, IPackedVector<uint>
     /// <inheritdoc/>
     public uint PackedValue
     {
-        [MethodImpl(InliningOptions.ShortMethod)]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         readonly get => Unsafe.As<La32, uint>(ref Unsafe.AsRef(in this));
 
-        [MethodImpl(InliningOptions.ShortMethod)]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         set => Unsafe.As<La32, uint>(ref this) = value;
     }
 
@@ -59,7 +59,7 @@ public partial struct La32 : IPixel<La32>, IPackedVector<uint>
     /// <returns>
     /// True if the <paramref name="left"/> parameter is equal to the <paramref name="right"/> parameter; otherwise, false.
     /// </returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator ==(La32 left, La32 right) => left.Equals(right);
 
     /// <summary>
@@ -70,186 +70,146 @@ public partial struct La32 : IPixel<La32>, IPackedVector<uint>
     /// <returns>
     /// True if the <paramref name="left"/> parameter is not equal to the <paramref name="right"/> parameter; otherwise, false.
     /// </returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator !=(La32 left, La32 right) => !left.Equals(right);
 
     /// <inheritdoc/>
-    public readonly PixelOperations<La32> CreatePixelOperations() => new PixelOperations();
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly Rgba32 ToRgba32()
+    {
+        byte rgb = ColorNumerics.From16BitTo8Bit(this.L);
+        return new(rgb, rgb, rgb, ColorNumerics.From16BitTo8Bit(this.A));
+    }
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public readonly bool Equals(La32 other) => this.PackedValue.Equals(other.PackedValue);
-
-    /// <inheritdoc />
-    public override readonly bool Equals(object? obj) => obj is La32 other && this.Equals(other);
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly Vector4 ToScaledVector4() => this.ToVector4();
 
-    /// <inheritdoc />
-    public override readonly string ToString() => $"La32({this.L}, {this.A})";
+    /// <inheritdoc/>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly Vector4 ToVector4()
+    {
+        float rgb = this.L / Max;
+        return new Vector4(rgb, rgb, rgb, this.A / Max);
+    }
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public override readonly int GetHashCode() => this.PackedValue.GetHashCode();
+    public static PixelTypeInfo GetPixelTypeInfo()
+        => PixelTypeInfo.Create<La32>(
+            PixelComponentInfo.Create<La32>(2, 16, 16),
+            PixelColorType.Grayscale | PixelColorType.Alpha,
+            PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromArgb32(Argb32 source)
-    {
-        this.L = ColorNumerics.Get16BitBT709Luminance(
-            ColorNumerics.UpscaleFrom8BitTo16Bit(source.R),
-            ColorNumerics.UpscaleFrom8BitTo16Bit(source.G),
-            ColorNumerics.UpscaleFrom8BitTo16Bit(source.B));
-
-        this.A = ColorNumerics.UpscaleFrom8BitTo16Bit(source.A);
-    }
+    public static PixelOperations<La32> CreatePixelOperations() => new PixelOperations();
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgr24(Bgr24 source)
-    {
-        this.L = ColorNumerics.Get16BitBT709Luminance(
-            ColorNumerics.UpscaleFrom8BitTo16Bit(source.R),
-            ColorNumerics.UpscaleFrom8BitTo16Bit(source.G),
-            ColorNumerics.UpscaleFrom8BitTo16Bit(source.B));
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static La32 FromScaledVector4(Vector4 source) => Pack(source);
 
-        this.A = ushort.MaxValue;
-    }
+    /// <inheritdoc/>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static La32 FromVector4(Vector4 source) => Pack(source);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgra32(Bgra32 source)
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static La32 FromAbgr32(Abgr32 source)
     {
-        this.L = ColorNumerics.Get16BitBT709Luminance(
-            ColorNumerics.UpscaleFrom8BitTo16Bit(source.R),
-            ColorNumerics.UpscaleFrom8BitTo16Bit(source.G),
-            ColorNumerics.UpscaleFrom8BitTo16Bit(source.B));
-
-        this.A = ColorNumerics.UpscaleFrom8BitTo16Bit(source.A);
+        ushort l = ColorNumerics.Get16BitBT709Luminance(source.R, source.G, source.B);
+        ushort a = ColorNumerics.From8BitTo16Bit(source.A);
+        return new(l, a);
     }
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromAbgr32(Abgr32 source)
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static La32 FromArgb32(Argb32 source)
     {
-        this.L = ColorNumerics.Get16BitBT709Luminance(
-            ColorNumerics.UpscaleFrom8BitTo16Bit(source.R),
-            ColorNumerics.UpscaleFrom8BitTo16Bit(source.G),
-            ColorNumerics.UpscaleFrom8BitTo16Bit(source.B));
-
-        this.A = ColorNumerics.UpscaleFrom8BitTo16Bit(source.A);
+        ushort l = ColorNumerics.Get16BitBT709Luminance(source.R, source.G, source.B);
+        ushort a = ColorNumerics.From8BitTo16Bit(source.A);
+        return new(l, a);
     }
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgra5551(Bgra5551 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static La32 FromBgra5551(Bgra5551 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromL16(L16 source)
-    {
-        this.L = source.PackedValue;
-        this.A = ushort.MaxValue;
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static La32 FromBgr24(Bgr24 source) => new(ColorNumerics.Get16BitBT709Luminance(source.R, source.G, source.B), ushort.MaxValue);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromL8(L8 source)
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static La32 FromBgra32(Bgra32 source)
     {
-        this.L = ColorNumerics.UpscaleFrom8BitTo16Bit(source.PackedValue);
-        this.A = ushort.MaxValue;
+        ushort l = ColorNumerics.Get16BitBT709Luminance(source.R, source.G, source.B);
+        ushort a = ColorNumerics.From8BitTo16Bit(source.A);
+        return new(l, a);
     }
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromLa16(La16 source)
-    {
-        this.L = ColorNumerics.UpscaleFrom8BitTo16Bit(source.L);
-        this.A = ColorNumerics.UpscaleFrom8BitTo16Bit(source.A);
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static La32 FromL16(L16 source) => new(source.PackedValue, ushort.MaxValue);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromLa32(La32 source) => this = source;
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static La32 FromL8(L8 source) => new(ColorNumerics.From8BitTo16Bit(source.PackedValue), ushort.MaxValue);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgb24(Rgb24 source)
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static La32 FromLa16(La16 source)
     {
-        this.L = ColorNumerics.Get16BitBT709Luminance(
-            ColorNumerics.UpscaleFrom8BitTo16Bit(source.R),
-            ColorNumerics.UpscaleFrom8BitTo16Bit(source.G),
-            ColorNumerics.UpscaleFrom8BitTo16Bit(source.B));
-
-        this.A = ushort.MaxValue;
+        ushort l = ColorNumerics.From8BitTo16Bit(source.L);
+        ushort a = ColorNumerics.From8BitTo16Bit(source.A);
+        return new(l, a);
     }
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgb48(Rgb48 source)
-    {
-        this.L = ColorNumerics.Get16BitBT709Luminance(source.R, source.G, source.B);
-        this.A = ushort.MaxValue;
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static La32 FromLa32(La32 source) => new(source.L, source.A);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgba32(Rgba32 source)
-    {
-        this.L = ColorNumerics.Get16BitBT709Luminance(
-            ColorNumerics.UpscaleFrom8BitTo16Bit(source.R),
-            ColorNumerics.UpscaleFrom8BitTo16Bit(source.G),
-            ColorNumerics.UpscaleFrom8BitTo16Bit(source.B));
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static La32 FromRgb24(Rgb24 source) => new(ColorNumerics.Get16BitBT709Luminance(source.R, source.G, source.B), ushort.MaxValue);
 
-        this.A = ColorNumerics.UpscaleFrom8BitTo16Bit(source.A);
+    /// <inheritdoc/>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static La32 FromRgb48(Rgb48 source)
+    {
+        ushort l = ColorNumerics.Get16BitBT709Luminance(source.R, source.G, source.B);
+        return new(l, ushort.MaxValue);
     }
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgba64(Rgba64 source)
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static La32 FromRgba32(Rgba32 source)
     {
-        this.L = ColorNumerics.Get16BitBT709Luminance(source.R, source.G, source.B);
-        this.A = source.A;
+        ushort l = ColorNumerics.Get16BitBT709Luminance(source.R, source.G, source.B);
+        ushort a = ColorNumerics.From8BitTo16Bit(source.A);
+        return new(l, a);
     }
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromScaledVector4(Vector4 vector) => this.ConvertFromRgbaScaledVector4(vector);
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static La32 FromRgba64(Rgba64 source) => new(ColorNumerics.Get16BitBT709Luminance(source.R, source.G, source.B), source.A);
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromVector4(Vector4 vector) => this.ConvertFromRgbaScaledVector4(vector);
+    /// <inheritdoc />
+    public override readonly bool Equals(object? obj) => obj is La32 other && this.Equals(other);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void ToRgba32(ref Rgba32 dest)
-    {
-        byte rgb = ColorNumerics.DownScaleFrom16BitTo8Bit(this.L);
-        dest.R = rgb;
-        dest.G = rgb;
-        dest.B = rgb;
-        dest.A = ColorNumerics.DownScaleFrom16BitTo8Bit(this.A);
-    }
+    public readonly bool Equals(La32 other) => this.PackedValue.Equals(other.PackedValue);
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public readonly Vector4 ToScaledVector4() => this.ToVector4();
+    /// <inheritdoc />
+    public override readonly string ToString() => $"La32({this.L}, {this.A})";
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public readonly Vector4 ToVector4()
-    {
-        float scaled = this.L / Max;
-        return new Vector4(scaled, scaled, scaled, this.A / Max);
-    }
+    /// <inheritdoc />
+    public override readonly int GetHashCode() => this.PackedValue.GetHashCode();
 
-    [MethodImpl(InliningOptions.ShortMethod)]
-    internal void ConvertFromRgbaScaledVector4(Vector4 vector)
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static La32 Pack(Vector4 vector)
     {
         vector = Numerics.Clamp(vector, Vector4.Zero, Vector4.One) * Max;
-        this.L = ColorNumerics.Get16BitBT709Luminance(
-            vector.X,
-            vector.Y,
-            vector.Z);
-
-        this.A = (ushort)MathF.Round(vector.W);
+        ushort l = ColorNumerics.Get16BitBT709Luminance(vector.X, vector.Y, vector.Z);
+        ushort a = (ushort)MathF.Round(vector.W);
+        return new(l, a);
     }
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedByte2.cs b/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedByte2.cs
index 92b9e6148..9551d7242 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedByte2.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedByte2.cs
@@ -14,10 +14,9 @@ namespace SixLabors.ImageSharp.PixelFormats;
 /// </summary>
 public partial struct NormalizedByte2 : IPixel<NormalizedByte2>, IPackedVector<ushort>
 {
-    private const float MaxPos = 127F;
-
+    private const float MaxPos = 127f;
     private static readonly Vector2 Half = new(MaxPos);
-    private static readonly Vector2 MinusOne = new(-1F);
+    private static readonly Vector2 MinusOne = new(-1f);
 
     /// <summary>
     /// Initializes a new instance of the <see cref="NormalizedByte2"/> struct.
@@ -46,7 +45,7 @@ public partial struct NormalizedByte2 : IPixel<NormalizedByte2>, IPackedVector<u
     /// <returns>
     /// True if the <paramref name="left"/> parameter is equal to the <paramref name="right"/> parameter; otherwise, false.
     /// </returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator ==(NormalizedByte2 left, NormalizedByte2 right) => left.Equals(right);
 
     /// <summary>
@@ -57,105 +56,108 @@ public partial struct NormalizedByte2 : IPixel<NormalizedByte2>, IPackedVector<u
     /// <returns>
     /// True if the <paramref name="left"/> parameter is not equal to the <paramref name="right"/> parameter; otherwise, false.
     /// </returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator !=(NormalizedByte2 left, NormalizedByte2 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public readonly PixelOperations<NormalizedByte2> CreatePixelOperations() => new PixelOperations();
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly Rgba32 ToRgba32() => Rgba32.FromScaledVector4(this.ToScaledVector4());
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromScaledVector4(Vector4 vector)
-    {
-        Vector2 scaled = new Vector2(vector.X, vector.Y) * 2F;
-        scaled -= Vector2.One;
-        this.PackedValue = Pack(scaled);
-    }
-
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public readonly Vector4 ToScaledVector4()
     {
-        var scaled = this.ToVector2();
+        Vector2 scaled = this.ToVector2();
         scaled += Vector2.One;
-        scaled /= 2F;
-        return new Vector4(scaled, 0F, 1F);
+        scaled /= 2f;
+        return new Vector4(scaled, 0f, 1f);
     }
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromVector4(Vector4 vector)
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly Vector4 ToVector4() => new(this.ToVector2(), 0f, 1f);
+
+    /// <inheritdoc />
+    public static PixelTypeInfo GetPixelTypeInfo()
+        => PixelTypeInfo.Create<NormalizedByte2>(
+            PixelComponentInfo.Create<NormalizedByte2>(2, 8, 8),
+            PixelColorType.Red | PixelColorType.Green,
+            PixelAlphaRepresentation.None);
+
+    /// <inheritdoc />
+    public static PixelOperations<NormalizedByte2> CreatePixelOperations() => new PixelOperations();
+
+    /// <inheritdoc/>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static NormalizedByte2 FromScaledVector4(Vector4 source)
     {
-        var vector2 = new Vector2(vector.X, vector.Y);
-        this.PackedValue = Pack(vector2);
+        Vector2 scaled = new Vector2(source.X, source.Y) * 2f;
+        scaled -= Vector2.One;
+        return new() { PackedValue = Pack(scaled) };
     }
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public readonly Vector4 ToVector4() => new(this.ToVector2(), 0F, 1F);
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static NormalizedByte2 FromVector4(Vector4 source) => new() { PackedValue = Pack(new Vector2(source.X, source.Y)) };
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromArgb32(Argb32 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static NormalizedByte2 FromAbgr32(Abgr32 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgr24(Bgr24 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static NormalizedByte2 FromArgb32(Argb32 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgra32(Bgra32 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static NormalizedByte2 FromBgra5551(Bgra5551 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromAbgr32(Abgr32 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static NormalizedByte2 FromBgr24(Bgr24 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgra5551(Bgra5551 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static NormalizedByte2 FromBgra32(Bgra32 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void ToRgba32(ref Rgba32 dest) => dest.FromScaledVector4(this.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static NormalizedByte2 FromL8(L8 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromL8(L8 source) => this.FromScaledVector4(source.ToScaledVector4());
-
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromL16(L16 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static NormalizedByte2 FromL16(L16 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromLa16(La16 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static NormalizedByte2 FromLa16(La16 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromLa32(La32 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static NormalizedByte2 FromLa32(La32 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgb24(Rgb24 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static NormalizedByte2 FromRgb24(Rgb24 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgba32(Rgba32 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static NormalizedByte2 FromRgba32(Rgba32 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgb48(Rgb48 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static NormalizedByte2 FromRgb48(Rgb48 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgba64(Rgba64 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static NormalizedByte2 FromRgba64(Rgba64 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <summary>
     /// Expands the packed representation into a <see cref="Vector2"/>.
     /// The vector components are typically expanded in least to greatest significance order.
     /// </summary>
     /// <returns>The <see cref="Vector2"/>.</returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public readonly Vector2 ToVector2() => new(
             (sbyte)((this.PackedValue >> 0) & 0xFF) / MaxPos,
             (sbyte)((this.PackedValue >> 8) & 0xFF) / MaxPos);
@@ -164,21 +166,19 @@ public partial struct NormalizedByte2 : IPixel<NormalizedByte2>, IPackedVector<u
     public override readonly bool Equals(object? obj) => obj is NormalizedByte2 other && this.Equals(other);
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
     public readonly bool Equals(NormalizedByte2 other) => this.PackedValue.Equals(other.PackedValue);
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
     public override readonly int GetHashCode() => this.PackedValue.GetHashCode();
 
     /// <inheritdoc />
     public override readonly string ToString()
     {
-        var vector = this.ToVector2();
+        Vector2 vector = this.ToVector2();
         return FormattableString.Invariant($"NormalizedByte2({vector.X:#0.##}, {vector.Y:#0.##})");
     }
 
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static ushort Pack(Vector2 vector)
     {
         vector = Vector2.Clamp(vector, MinusOne, Vector2.One) * Half;
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedByte4.cs b/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedByte4.cs
index f87bb5a60..1fb386725 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedByte4.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedByte4.cs
@@ -3,6 +3,7 @@
 
 using System.Numerics;
 using System.Runtime.CompilerServices;
+using System.Runtime.Intrinsics;
 
 namespace SixLabors.ImageSharp.PixelFormats;
 
@@ -14,10 +15,9 @@ namespace SixLabors.ImageSharp.PixelFormats;
 /// </summary>
 public partial struct NormalizedByte4 : IPixel<NormalizedByte4>, IPackedVector<uint>
 {
-    private const float MaxPos = 127F;
-
-    private static readonly Vector4 Half = new(MaxPos);
-    private static readonly Vector4 MinusOne = new(-1F);
+    private const float MaxPos = 127f;
+    private static readonly Vector4 Half = Vector128.Create(MaxPos).AsVector4();
+    private static readonly Vector4 MinusOne = Vector128.Create(-1f).AsVector4();
 
     /// <summary>
     /// Initializes a new instance of the <see cref="NormalizedByte4"/> struct.
@@ -35,7 +35,7 @@ public partial struct NormalizedByte4 : IPixel<NormalizedByte4>, IPackedVector<u
     /// Initializes a new instance of the <see cref="NormalizedByte4"/> struct.
     /// </summary>
     /// <param name="vector">The vector containing the component values.</param>
-    public NormalizedByte4(Vector4 vector) => this.PackedValue = Pack(ref vector);
+    public NormalizedByte4(Vector4 vector) => this.PackedValue = Pack(vector);
 
     /// <inheritdoc/>
     public uint PackedValue { get; set; }
@@ -48,7 +48,7 @@ public partial struct NormalizedByte4 : IPixel<NormalizedByte4>, IPackedVector<u
     /// <returns>
     /// True if the <paramref name="left"/> parameter is equal to the <paramref name="right"/> parameter; otherwise, false.
     /// </returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator ==(NormalizedByte4 left, NormalizedByte4 right) => left.Equals(right);
 
     /// <summary>
@@ -59,37 +59,25 @@ public partial struct NormalizedByte4 : IPixel<NormalizedByte4>, IPackedVector<u
     /// <returns>
     /// True if the <paramref name="left"/> parameter is not equal to the <paramref name="right"/> parameter; otherwise, false.
     /// </returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator !=(NormalizedByte4 left, NormalizedByte4 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public readonly PixelOperations<NormalizedByte4> CreatePixelOperations() => new PixelOperations();
-
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromScaledVector4(Vector4 vector)
-    {
-        vector *= 2F;
-        vector -= Vector4.One;
-        this.FromVector4(vector);
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly Rgba32 ToRgba32() => Rgba32.FromScaledVector4(this.ToScaledVector4());
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public readonly Vector4 ToScaledVector4()
     {
-        var scaled = this.ToVector4();
+        Vector4 scaled = this.ToVector4();
         scaled += Vector4.One;
-        scaled /= 2F;
+        scaled /= 2f;
         return scaled;
     }
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromVector4(Vector4 vector) => this.PackedValue = Pack(ref vector);
-
-    /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public readonly Vector4 ToVector4() => new(
             (sbyte)((this.PackedValue >> 0) & 0xFF) / MaxPos,
             (sbyte)((this.PackedValue >> 8) & 0xFF) / MaxPos,
@@ -97,81 +85,98 @@ public partial struct NormalizedByte4 : IPixel<NormalizedByte4>, IPackedVector<u
             (sbyte)((this.PackedValue >> 24) & 0xFF) / MaxPos);
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromArgb32(Argb32 source) => this.FromScaledVector4(source.ToScaledVector4());
+    public static PixelTypeInfo GetPixelTypeInfo()
+        => PixelTypeInfo.Create<NormalizedByte4>(
+            PixelComponentInfo.Create<NormalizedByte4>(4, 8, 8, 8, 8),
+            PixelColorType.RGB | PixelColorType.Alpha,
+            PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgr24(Bgr24 source) => this.FromScaledVector4(source.ToScaledVector4());
+    public static PixelOperations<NormalizedByte4> CreatePixelOperations() => new PixelOperations();
+
+    /// <inheritdoc/>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static NormalizedByte4 FromScaledVector4(Vector4 source)
+    {
+        source *= 2f;
+        source -= Vector4.One;
+        return FromVector4(source);
+    }
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgra32(Bgra32 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static NormalizedByte4 FromAbgr32(Abgr32 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromAbgr32(Abgr32 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static NormalizedByte4 FromArgb32(Argb32 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgra5551(Bgra5551 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static NormalizedByte4 FromBgra5551(Bgra5551 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromL8(L8 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static NormalizedByte4 FromBgr24(Bgr24 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromL16(L16 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static NormalizedByte4 FromBgra32(Bgra32 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromLa16(La16 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static NormalizedByte4 FromL8(L8 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromLa32(La32 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static NormalizedByte4 FromL16(L16 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgb24(Rgb24 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static NormalizedByte4 FromLa16(La16 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgba32(Rgba32 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static NormalizedByte4 FromLa32(La32 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void ToRgba32(ref Rgba32 dest) => dest.FromScaledVector4(this.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static NormalizedByte4 FromRgb24(Rgb24 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgb48(Rgb48 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static NormalizedByte4 FromRgba32(Rgba32 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgba64(Rgba64 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static NormalizedByte4 FromRgb48(Rgb48 source) => FromScaledVector4(source.ToScaledVector4());
+
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static NormalizedByte4 FromRgba64(Rgba64 source) => FromScaledVector4(source.ToScaledVector4());
+
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static NormalizedByte4 FromVector4(Vector4 source) => new() { PackedValue = Pack(source) };
 
     /// <inheritdoc />
     public override readonly bool Equals(object? obj) => obj is NormalizedByte4 other && this.Equals(other);
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
     public readonly bool Equals(NormalizedByte4 other) => this.PackedValue.Equals(other.PackedValue);
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
     public override readonly int GetHashCode() => this.PackedValue.GetHashCode();
 
     /// <inheritdoc />
     public override readonly string ToString()
     {
-        var vector = this.ToVector4();
+        Vector4 vector = this.ToVector4();
         return FormattableString.Invariant($"NormalizedByte4({vector.X:#0.##}, {vector.Y:#0.##}, {vector.Z:#0.##}, {vector.W:#0.##})");
     }
 
-    [MethodImpl(InliningOptions.ShortMethod)]
-    private static uint Pack(ref Vector4 vector)
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static uint Pack(Vector4 vector)
     {
         vector = Numerics.Clamp(vector, MinusOne, Vector4.One) * Half;
 
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedShort2.cs b/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedShort2.cs
index f77dd69b7..a17868f6d 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedShort2.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedShort2.cs
@@ -47,7 +47,7 @@ public partial struct NormalizedShort2 : IPixel<NormalizedShort2>, IPackedVector
     /// <returns>
     /// True if the <paramref name="left"/> parameter is equal to the <paramref name="right"/> parameter; otherwise, false.
     /// </returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator ==(NormalizedShort2 left, NormalizedShort2 right) => left.Equals(right);
 
     /// <summary>
@@ -58,105 +58,108 @@ public partial struct NormalizedShort2 : IPixel<NormalizedShort2>, IPackedVector
     /// <returns>
     /// True if the <paramref name="left"/> parameter is not equal to the <paramref name="right"/> parameter; otherwise, false.
     /// </returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator !=(NormalizedShort2 left, NormalizedShort2 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public readonly PixelOperations<NormalizedShort2> CreatePixelOperations() => new PixelOperations();
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly Rgba32 ToRgba32() => Rgba32.FromScaledVector4(this.ToScaledVector4());
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromScaledVector4(Vector4 vector)
-    {
-        Vector2 scaled = new Vector2(vector.X, vector.Y) * 2F;
-        scaled -= Vector2.One;
-        this.PackedValue = Pack(scaled);
-    }
-
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public readonly Vector4 ToScaledVector4()
     {
-        var scaled = this.ToVector2();
+        Vector2 scaled = this.ToVector2();
         scaled += Vector2.One;
-        scaled /= 2F;
-        return new Vector4(scaled, 0F, 1F);
+        scaled /= 2f;
+        return new Vector4(scaled, 0f, 1f);
     }
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromVector4(Vector4 vector)
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly Vector4 ToVector4() => new(this.ToVector2(), 0f, 1f);
+
+    /// <inheritdoc />
+    public static PixelTypeInfo GetPixelTypeInfo()
+        => PixelTypeInfo.Create<NormalizedShort2>(
+            PixelComponentInfo.Create<NormalizedShort2>(2, 16, 16),
+            PixelColorType.Red | PixelColorType.Green,
+            PixelAlphaRepresentation.None);
+
+    /// <inheritdoc />
+    public static PixelOperations<NormalizedShort2> CreatePixelOperations() => new PixelOperations();
+
+    /// <inheritdoc/>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static NormalizedShort2 FromScaledVector4(Vector4 source)
     {
-        var vector2 = new Vector2(vector.X, vector.Y);
-        this.PackedValue = Pack(vector2);
+        Vector2 scaled = new Vector2(source.X, source.Y) * 2f;
+        scaled -= Vector2.One;
+        return new() { PackedValue = Pack(scaled) };
     }
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public readonly Vector4 ToVector4() => new Vector4(this.ToVector2(), 0, 1);
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static NormalizedShort2 FromVector4(Vector4 source) => new() { PackedValue = Pack(new Vector2(source.X, source.Y)) };
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromArgb32(Argb32 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static NormalizedShort2 FromAbgr32(Abgr32 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgr24(Bgr24 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static NormalizedShort2 FromArgb32(Argb32 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgra32(Bgra32 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static NormalizedShort2 FromBgra5551(Bgra5551 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromAbgr32(Abgr32 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static NormalizedShort2 FromBgr24(Bgr24 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgra5551(Bgra5551 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static NormalizedShort2 FromBgra32(Bgra32 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromL8(L8 source) => this.FromScaledVector4(source.ToScaledVector4());
-
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromL16(L16 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static NormalizedShort2 FromL8(L8 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromLa16(La16 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static NormalizedShort2 FromL16(L16 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromLa32(La32 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static NormalizedShort2 FromLa16(La16 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgb24(Rgb24 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static NormalizedShort2 FromLa32(La32 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgba32(Rgba32 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static NormalizedShort2 FromRgb24(Rgb24 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void ToRgba32(ref Rgba32 dest) => dest.FromScaledVector4(this.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static NormalizedShort2 FromRgba32(Rgba32 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgb48(Rgb48 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static NormalizedShort2 FromRgb48(Rgb48 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgba64(Rgba64 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static NormalizedShort2 FromRgba64(Rgba64 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <summary>
     /// Expands the packed representation into a <see cref="Vector2"/>.
     /// The vector components are typically expanded in least to greatest significance order.
     /// </summary>
     /// <returns>The <see cref="Vector2"/>.</returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public readonly Vector2 ToVector2() => new(
             (short)(this.PackedValue & 0xFFFF) / MaxPos,
             (short)(this.PackedValue >> 0x10) / MaxPos);
@@ -165,21 +168,19 @@ public partial struct NormalizedShort2 : IPixel<NormalizedShort2>, IPackedVector
     public override readonly bool Equals(object? obj) => obj is NormalizedShort2 other && this.Equals(other);
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
     public readonly bool Equals(NormalizedShort2 other) => this.PackedValue.Equals(other.PackedValue);
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
     public override readonly int GetHashCode() => this.PackedValue.GetHashCode();
 
     /// <inheritdoc />
     public override readonly string ToString()
     {
-        var vector = this.ToVector2();
+        Vector2 vector = this.ToVector2();
         return FormattableString.Invariant($"NormalizedShort2({vector.X:#0.##}, {vector.Y:#0.##})");
     }
 
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static uint Pack(Vector2 vector)
     {
         vector *= Max;
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedShort4.cs b/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedShort4.cs
index 989edbd2b..2b33fec27 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedShort4.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedShort4.cs
@@ -3,6 +3,7 @@
 
 using System.Numerics;
 using System.Runtime.CompilerServices;
+using System.Runtime.Intrinsics;
 
 namespace SixLabors.ImageSharp.PixelFormats;
 
@@ -16,8 +17,7 @@ public partial struct NormalizedShort4 : IPixel<NormalizedShort4>, IPackedVector
 {
     // Largest two byte positive number 0xFFFF >> 1;
     private const float MaxPos = 0x7FFF;
-
-    private static readonly Vector4 Max = new(MaxPos);
+    private static readonly Vector4 Max = Vector128.Create(MaxPos).AsVector4();
     private static readonly Vector4 Min = Vector4.Negate(Max);
 
     /// <summary>
@@ -36,7 +36,7 @@ public partial struct NormalizedShort4 : IPixel<NormalizedShort4>, IPackedVector
     /// Initializes a new instance of the <see cref="NormalizedShort4"/> struct.
     /// </summary>
     /// <param name="vector">The vector containing the component values.</param>
-    public NormalizedShort4(Vector4 vector) => this.PackedValue = Pack(ref vector);
+    public NormalizedShort4(Vector4 vector) => this.PackedValue = Pack(vector);
 
     /// <inheritdoc/>
     public ulong PackedValue { get; set; }
@@ -49,7 +49,7 @@ public partial struct NormalizedShort4 : IPixel<NormalizedShort4>, IPackedVector
     /// <returns>
     /// True if the <paramref name="left"/> parameter is equal to the <paramref name="right"/> parameter; otherwise, false.
     /// </returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator ==(NormalizedShort4 left, NormalizedShort4 right) => left.Equals(right);
 
     /// <summary>
@@ -60,37 +60,25 @@ public partial struct NormalizedShort4 : IPixel<NormalizedShort4>, IPackedVector
     /// <returns>
     /// True if the <paramref name="left"/> parameter is not equal to the <paramref name="right"/> parameter; otherwise, false.
     /// </returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator !=(NormalizedShort4 left, NormalizedShort4 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public readonly PixelOperations<NormalizedShort4> CreatePixelOperations() => new PixelOperations();
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly Rgba32 ToRgba32() => Rgba32.FromScaledVector4(this.ToScaledVector4());
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromScaledVector4(Vector4 vector)
-    {
-        vector *= 2F;
-        vector -= Vector4.One;
-        this.FromVector4(vector);
-    }
-
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public readonly Vector4 ToScaledVector4()
     {
-        var scaled = this.ToVector4();
+        Vector4 scaled = this.ToVector4();
         scaled += Vector4.One;
-        scaled /= 2F;
+        scaled /= 2f;
         return scaled;
     }
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromVector4(Vector4 vector) => this.PackedValue = Pack(ref vector);
-
-    /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public readonly Vector4 ToVector4() => new(
                      (short)((this.PackedValue >> 0x00) & 0xFFFF) / MaxPos,
                      (short)((this.PackedValue >> 0x10) & 0xFFFF) / MaxPos,
@@ -98,81 +86,98 @@ public partial struct NormalizedShort4 : IPixel<NormalizedShort4>, IPackedVector
                      (short)((this.PackedValue >> 0x30) & 0xFFFF) / MaxPos);
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromArgb32(Argb32 source) => this.FromScaledVector4(source.ToScaledVector4());
+    public static PixelTypeInfo GetPixelTypeInfo()
+        => PixelTypeInfo.Create<NormalizedShort4>(
+            PixelComponentInfo.Create<NormalizedShort4>(4, 16, 16, 16, 16),
+            PixelColorType.RGB | PixelColorType.Alpha,
+            PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgr24(Bgr24 source) => this.FromScaledVector4(source.ToScaledVector4());
+    public static PixelOperations<NormalizedShort4> CreatePixelOperations() => new PixelOperations();
+
+    /// <inheritdoc/>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static NormalizedShort4 FromScaledVector4(Vector4 source)
+    {
+        source *= 2f;
+        source -= Vector4.One;
+        return FromVector4(source);
+    }
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgra32(Bgra32 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static NormalizedShort4 FromVector4(Vector4 source) => new() { PackedValue = Pack(source) };
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromAbgr32(Abgr32 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static NormalizedShort4 FromAbgr32(Abgr32 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgra5551(Bgra5551 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static NormalizedShort4 FromArgb32(Argb32 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromL8(L8 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static NormalizedShort4 FromBgra5551(Bgra5551 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromL16(L16 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static NormalizedShort4 FromBgr24(Bgr24 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromLa16(La16 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static NormalizedShort4 FromBgra32(Bgra32 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromLa32(La32 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static NormalizedShort4 FromL8(L8 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgb24(Rgb24 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static NormalizedShort4 FromL16(L16 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgba32(Rgba32 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static NormalizedShort4 FromLa16(La16 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void ToRgba32(ref Rgba32 dest) => dest.FromScaledVector4(this.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static NormalizedShort4 FromLa32(La32 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgb48(Rgb48 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static NormalizedShort4 FromRgb24(Rgb24 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgba64(Rgba64 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static NormalizedShort4 FromRgba32(Rgba32 source) => FromScaledVector4(source.ToScaledVector4());
+
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static NormalizedShort4 FromRgb48(Rgb48 source) => FromScaledVector4(source.ToScaledVector4());
+
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static NormalizedShort4 FromRgba64(Rgba64 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc />
     public override readonly bool Equals(object? obj) => obj is NormalizedShort4 other && this.Equals(other);
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
     public readonly bool Equals(NormalizedShort4 other) => this.PackedValue.Equals(other.PackedValue);
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
     public override readonly int GetHashCode() => this.PackedValue.GetHashCode();
 
     /// <inheritdoc />
     public override readonly string ToString()
     {
-        var vector = this.ToVector4();
+        Vector4 vector = this.ToVector4();
         return FormattableString.Invariant($"NormalizedShort4({vector.X:#0.##}, {vector.Y:#0.##}, {vector.Z:#0.##}, {vector.W:#0.##})");
     }
 
-    [MethodImpl(InliningOptions.ShortMethod)]
-    private static ulong Pack(ref Vector4 vector)
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static ulong Pack(Vector4 vector)
     {
         vector *= Max;
         vector = Numerics.Clamp(vector, Min, Max);
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/A8.PixelOperations.cs b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/A8.PixelOperations.cs
index a7b4b5df0..da0e6ec60 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/A8.PixelOperations.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/A8.PixelOperations.cs
@@ -1,8 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using SixLabors.ImageSharp.Formats;
-
 namespace SixLabors.ImageSharp.PixelFormats;
 
 /// <content>
@@ -13,12 +11,5 @@ public partial struct A8
     /// <summary>
     /// Provides optimized overrides for bulk operations.
     /// </summary>
-    internal class PixelOperations : PixelOperations<A8>
-    {
-        private static readonly Lazy<PixelTypeInfo> LazyInfo =
-            new Lazy<PixelTypeInfo>(() => PixelTypeInfo.Create<A8>(PixelAlphaRepresentation.Unassociated), true);
-
-        /// <inheritdoc />
-        public override PixelTypeInfo GetPixelTypeInfo() => LazyInfo.Value;
-    }
+    internal class PixelOperations : PixelOperations<A8>;
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Abgr32.PixelOperations.cs b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Abgr32.PixelOperations.cs
index 66f3ecb24..d459fc4d6 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Abgr32.PixelOperations.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Abgr32.PixelOperations.cs
@@ -1,8 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using SixLabors.ImageSharp.Formats;
-
 namespace SixLabors.ImageSharp.PixelFormats;
 
 /// <content>
@@ -13,12 +11,5 @@ public partial struct Abgr32
     /// <summary>
     /// Provides optimized overrides for bulk operations.
     /// </summary>
-    internal partial class PixelOperations : PixelOperations<Abgr32>
-    {
-        private static readonly Lazy<PixelTypeInfo> LazyInfo =
-            new Lazy<PixelTypeInfo>(() => PixelTypeInfo.Create<Abgr32>(PixelAlphaRepresentation.Unassociated), true);
-
-        /// <inheritdoc />
-        public override PixelTypeInfo GetPixelTypeInfo() => LazyInfo.Value;
-    }
+    internal partial class PixelOperations : PixelOperations<Abgr32>;
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Argb32.PixelOperations.cs b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Argb32.PixelOperations.cs
index 894e92963..608d618d4 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Argb32.PixelOperations.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Argb32.PixelOperations.cs
@@ -1,8 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using SixLabors.ImageSharp.Formats;
-
 namespace SixLabors.ImageSharp.PixelFormats;
 
 /// <content>
@@ -13,12 +11,5 @@ public partial struct Argb32
     /// <summary>
     /// Provides optimized overrides for bulk operations.
     /// </summary>
-    internal partial class PixelOperations : PixelOperations<Argb32>
-    {
-        private static readonly Lazy<PixelTypeInfo> LazyInfo =
-            new Lazy<PixelTypeInfo>(() => PixelTypeInfo.Create<Argb32>(PixelAlphaRepresentation.Unassociated), true);
-
-        /// <inheritdoc />
-        public override PixelTypeInfo GetPixelTypeInfo() => LazyInfo.Value;
-    }
+    internal partial class PixelOperations : PixelOperations<Argb32>;
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Bgr24.PixelOperations.cs b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Bgr24.PixelOperations.cs
index a8f6ab155..36ffff714 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Bgr24.PixelOperations.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Bgr24.PixelOperations.cs
@@ -1,8 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using SixLabors.ImageSharp.Formats;
-
 namespace SixLabors.ImageSharp.PixelFormats;
 
 /// <content>
@@ -13,12 +11,5 @@ public partial struct Bgr24
     /// <summary>
     /// Provides optimized overrides for bulk operations.
     /// </summary>
-    internal partial class PixelOperations : PixelOperations<Bgr24>
-    {
-        private static readonly Lazy<PixelTypeInfo> LazyInfo =
-            new Lazy<PixelTypeInfo>(() => PixelTypeInfo.Create<Bgr24>(PixelAlphaRepresentation.None), true);
-
-        /// <inheritdoc />
-        public override PixelTypeInfo GetPixelTypeInfo() => LazyInfo.Value;
-    }
+    internal partial class PixelOperations : PixelOperations<Bgr24>;
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Bgr565.PixelOperations.cs b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Bgr565.PixelOperations.cs
index de9690325..87175fe21 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Bgr565.PixelOperations.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Bgr565.PixelOperations.cs
@@ -1,8 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using SixLabors.ImageSharp.Formats;
-
 namespace SixLabors.ImageSharp.PixelFormats;
 
 /// <content>
@@ -13,12 +11,5 @@ public partial struct Bgr565
     /// <summary>
     /// Provides optimized overrides for bulk operations.
     /// </summary>
-    internal class PixelOperations : PixelOperations<Bgr565>
-    {
-        private static readonly Lazy<PixelTypeInfo> LazyInfo =
-            new Lazy<PixelTypeInfo>(() => PixelTypeInfo.Create<Bgr565>(PixelAlphaRepresentation.None), true);
-
-        /// <inheritdoc />
-        public override PixelTypeInfo GetPixelTypeInfo() => LazyInfo.Value;
-    }
+    internal class PixelOperations : PixelOperations<Bgr565>;
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Bgra32.PixelOperations.cs b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Bgra32.PixelOperations.cs
index 1a62b0809..d2c2b2db7 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Bgra32.PixelOperations.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Bgra32.PixelOperations.cs
@@ -1,8 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using SixLabors.ImageSharp.Formats;
-
 namespace SixLabors.ImageSharp.PixelFormats;
 
 /// <content>
@@ -13,12 +11,5 @@ public partial struct Bgra32
     /// <summary>
     /// Provides optimized overrides for bulk operations.
     /// </summary>
-    internal partial class PixelOperations : PixelOperations<Bgra32>
-    {
-        private static readonly Lazy<PixelTypeInfo> LazyInfo =
-            new Lazy<PixelTypeInfo>(() => PixelTypeInfo.Create<Bgra32>(PixelAlphaRepresentation.Unassociated), true);
-
-        /// <inheritdoc />
-        public override PixelTypeInfo GetPixelTypeInfo() => LazyInfo.Value;
-    }
+    internal partial class PixelOperations : PixelOperations<Bgra32>;
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Bgra4444.PixelOperations.cs b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Bgra4444.PixelOperations.cs
index 8ffdaf6cb..1a0be8b6f 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Bgra4444.PixelOperations.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Bgra4444.PixelOperations.cs
@@ -1,8 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using SixLabors.ImageSharp.Formats;
-
 namespace SixLabors.ImageSharp.PixelFormats;
 
 /// <content>
@@ -13,12 +11,5 @@ public partial struct Bgra4444
     /// <summary>
     /// Provides optimized overrides for bulk operations.
     /// </summary>
-    internal class PixelOperations : PixelOperations<Bgra4444>
-    {
-        private static readonly Lazy<PixelTypeInfo> LazyInfo =
-            new Lazy<PixelTypeInfo>(() => PixelTypeInfo.Create<Bgra4444>(PixelAlphaRepresentation.Unassociated), true);
-
-        /// <inheritdoc />
-        public override PixelTypeInfo GetPixelTypeInfo() => LazyInfo.Value;
-    }
+    internal class PixelOperations : PixelOperations<Bgra4444>;
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Bgra5551.PixelOperations.cs b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Bgra5551.PixelOperations.cs
index 97f5d805e..3a2856125 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Bgra5551.PixelOperations.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Bgra5551.PixelOperations.cs
@@ -1,8 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using SixLabors.ImageSharp.Formats;
-
 namespace SixLabors.ImageSharp.PixelFormats;
 
 /// <content>
@@ -13,12 +11,5 @@ public partial struct Bgra5551
     /// <summary>
     /// Provides optimized overrides for bulk operations.
     /// </summary>
-    internal partial class PixelOperations : PixelOperations<Bgra5551>
-    {
-        private static readonly Lazy<PixelTypeInfo> LazyInfo =
-            new Lazy<PixelTypeInfo>(() => PixelTypeInfo.Create<Bgra5551>(PixelAlphaRepresentation.Unassociated), true);
-
-        /// <inheritdoc />
-        public override PixelTypeInfo GetPixelTypeInfo() => LazyInfo.Value;
-    }
+    internal partial class PixelOperations : PixelOperations<Bgra5551>;
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Byte4.PixelOperations.cs b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Byte4.PixelOperations.cs
index f6e0b833c..c012547c9 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Byte4.PixelOperations.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Byte4.PixelOperations.cs
@@ -1,8 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using SixLabors.ImageSharp.Formats;
-
 namespace SixLabors.ImageSharp.PixelFormats;
 
 /// <content>
@@ -13,12 +11,5 @@ public partial struct Byte4
     /// <summary>
     /// Provides optimized overrides for bulk operations.
     /// </summary>
-    internal class PixelOperations : PixelOperations<Byte4>
-    {
-        private static readonly Lazy<PixelTypeInfo> LazyInfo =
-            new Lazy<PixelTypeInfo>(() => PixelTypeInfo.Create<Byte4>(PixelAlphaRepresentation.Unassociated), true);
-
-        /// <inheritdoc />
-        public override PixelTypeInfo GetPixelTypeInfo() => LazyInfo.Value;
-    }
+    internal class PixelOperations : PixelOperations<Byte4>;
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Generated/Abgr32.PixelOperations.Generated.cs b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Generated/Abgr32.PixelOperations.Generated.cs
index f24ed6fae..a5e4e3048 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Generated/Abgr32.PixelOperations.Generated.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Generated/Abgr32.PixelOperations.Generated.cs
@@ -21,337 +21,316 @@ public partial struct Abgr32
     internal partial class PixelOperations : PixelOperations<Abgr32>
     {
         /// <inheritdoc />
-        public override void FromAbgr32(Configuration configuration, ReadOnlySpan<Abgr32> source, Span<Abgr32> destinationPixels)
+        public override void FromAbgr32(Configuration configuration, ReadOnlySpan<Abgr32> source, Span<Abgr32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(source, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            source.CopyTo(destinationPixels.Slice(0, source.Length));
+            source.CopyTo(destination.Slice(0, source.Length));
         }
 
         /// <inheritdoc />
-        public override void ToAbgr32(Configuration configuration, ReadOnlySpan<Abgr32> sourcePixels, Span<Abgr32> destinationPixels)
+        public override void ToAbgr32(Configuration configuration, ReadOnlySpan<Abgr32> source, Span<Abgr32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            sourcePixels.CopyTo(destinationPixels.Slice(0, sourcePixels.Length));
+            source.CopyTo(destination.Slice(0, source.Length));
         }
 
         /// <inheritdoc />
         public override void FromVector4Destructive(
             Configuration configuration,
             Span<Vector4> sourceVectors,
-            Span<Abgr32> destinationPixels,
+            Span<Abgr32> destination,
             PixelConversionModifiers modifiers)
         {
-            Vector4Converters.RgbaCompatible.FromVector4(configuration, this, sourceVectors, destinationPixels, modifiers.Remove(PixelConversionModifiers.Scale));
+            Vector4Converters.RgbaCompatible.FromVector4(configuration, this, sourceVectors, destination, modifiers.Remove(PixelConversionModifiers.Scale));
         }
 
         /// <inheritdoc />
         public override void ToVector4(
             Configuration configuration,
-            ReadOnlySpan<Abgr32> sourcePixels,
-            Span<Vector4> destVectors,
+            ReadOnlySpan<Abgr32> source,
+            Span<Vector4> destination,
             PixelConversionModifiers modifiers)
         {
-            Vector4Converters.RgbaCompatible.ToVector4(configuration, this, sourcePixels, destVectors, modifiers.Remove(PixelConversionModifiers.Scale));
+            Vector4Converters.RgbaCompatible.ToVector4(configuration, this, source, destination, modifiers.Remove(PixelConversionModifiers.Scale));
         }
     
         /// <inheritdoc />
         public override void ToRgba32(
             Configuration configuration,
-            ReadOnlySpan<Abgr32> sourcePixels,
-            Span<Rgba32> destinationPixels)
+            ReadOnlySpan<Abgr32> source,
+            Span<Rgba32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ReadOnlySpan<byte> source = MemoryMarshal.Cast<Abgr32, byte>(sourcePixels);
-            Span<byte> dest = MemoryMarshal.Cast<Rgba32, byte>(destinationPixels);
-            PixelConverter.FromAbgr32.ToRgba32(source, dest);
+            ReadOnlySpan<byte> sourceBytes = MemoryMarshal.Cast<Abgr32, byte>(source);
+            Span<byte> destinationBytes = MemoryMarshal.Cast<Rgba32, byte>(destination);
+            PixelConverter.FromAbgr32.ToRgba32(sourceBytes, destinationBytes);
         }
         
         /// <inheritdoc />
         public override void FromRgba32(
             Configuration configuration,
-            ReadOnlySpan<Rgba32> sourcePixels,
-            Span<Abgr32> destinationPixels)
+            ReadOnlySpan<Rgba32> source,
+            Span<Abgr32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ReadOnlySpan<byte> source = MemoryMarshal.Cast<Rgba32, byte>(sourcePixels);
-            Span<byte> dest = MemoryMarshal.Cast<Abgr32, byte>(destinationPixels);
-            PixelConverter.FromRgba32.ToAbgr32(source, dest);
+            ReadOnlySpan<byte> sourceBytes = MemoryMarshal.Cast<Rgba32, byte>(source);
+            Span<byte> destinationBytes = MemoryMarshal.Cast<Abgr32, byte>(destination);
+            PixelConverter.FromRgba32.ToAbgr32(sourceBytes, destinationBytes);
         }        
     
         /// <inheritdoc />
         public override void ToArgb32(
             Configuration configuration,
-            ReadOnlySpan<Abgr32> sourcePixels,
-            Span<Argb32> destinationPixels)
+            ReadOnlySpan<Abgr32> source,
+            Span<Argb32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ReadOnlySpan<byte> source = MemoryMarshal.Cast<Abgr32, byte>(sourcePixels);
-            Span<byte> dest = MemoryMarshal.Cast<Argb32, byte>(destinationPixels);
-            PixelConverter.FromAbgr32.ToArgb32(source, dest);
+            ReadOnlySpan<byte> sourceBytes = MemoryMarshal.Cast<Abgr32, byte>(source);
+            Span<byte> destinationBytes = MemoryMarshal.Cast<Argb32, byte>(destination);
+            PixelConverter.FromAbgr32.ToArgb32(sourceBytes, destinationBytes);
         }
         
         /// <inheritdoc />
         public override void FromArgb32(
             Configuration configuration,
-            ReadOnlySpan<Argb32> sourcePixels,
-            Span<Abgr32> destinationPixels)
+            ReadOnlySpan<Argb32> source,
+            Span<Abgr32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ReadOnlySpan<byte> source = MemoryMarshal.Cast<Argb32, byte>(sourcePixels);
-            Span<byte> dest = MemoryMarshal.Cast<Abgr32, byte>(destinationPixels);
-            PixelConverter.FromArgb32.ToAbgr32(source, dest);
+            ReadOnlySpan<byte> sourceBytes = MemoryMarshal.Cast<Argb32, byte>(source);
+            Span<byte> destinationBytes = MemoryMarshal.Cast<Abgr32, byte>(destination);
+            PixelConverter.FromArgb32.ToAbgr32(sourceBytes, destinationBytes);
         }        
     
         /// <inheritdoc />
         public override void ToBgra32(
             Configuration configuration,
-            ReadOnlySpan<Abgr32> sourcePixels,
-            Span<Bgra32> destinationPixels)
+            ReadOnlySpan<Abgr32> source,
+            Span<Bgra32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ReadOnlySpan<byte> source = MemoryMarshal.Cast<Abgr32, byte>(sourcePixels);
-            Span<byte> dest = MemoryMarshal.Cast<Bgra32, byte>(destinationPixels);
-            PixelConverter.FromAbgr32.ToBgra32(source, dest);
+            ReadOnlySpan<byte> sourceBytes = MemoryMarshal.Cast<Abgr32, byte>(source);
+            Span<byte> destinationBytes = MemoryMarshal.Cast<Bgra32, byte>(destination);
+            PixelConverter.FromAbgr32.ToBgra32(sourceBytes, destinationBytes);
         }
         
         /// <inheritdoc />
         public override void FromBgra32(
             Configuration configuration,
-            ReadOnlySpan<Bgra32> sourcePixels,
-            Span<Abgr32> destinationPixels)
+            ReadOnlySpan<Bgra32> source,
+            Span<Abgr32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ReadOnlySpan<byte> source = MemoryMarshal.Cast<Bgra32, byte>(sourcePixels);
-            Span<byte> dest = MemoryMarshal.Cast<Abgr32, byte>(destinationPixels);
-            PixelConverter.FromBgra32.ToAbgr32(source, dest);
+            ReadOnlySpan<byte> sourceBytes = MemoryMarshal.Cast<Bgra32, byte>(source);
+            Span<byte> destinationBytes = MemoryMarshal.Cast<Abgr32, byte>(destination);
+            PixelConverter.FromBgra32.ToAbgr32(sourceBytes, destinationBytes);
         }        
     
         /// <inheritdoc />
         public override void ToRgb24(
             Configuration configuration,
-            ReadOnlySpan<Abgr32> sourcePixels,
-            Span<Rgb24> destinationPixels)
+            ReadOnlySpan<Abgr32> source,
+            Span<Rgb24> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ReadOnlySpan<byte> source = MemoryMarshal.Cast<Abgr32, byte>(sourcePixels);
-            Span<byte> dest = MemoryMarshal.Cast<Rgb24, byte>(destinationPixels);
-            PixelConverter.FromAbgr32.ToRgb24(source, dest);
+            ReadOnlySpan<byte> sourceBytes = MemoryMarshal.Cast<Abgr32, byte>(source);
+            Span<byte> destinationBytes = MemoryMarshal.Cast<Rgb24, byte>(destination);
+            PixelConverter.FromAbgr32.ToRgb24(sourceBytes, destinationBytes);
         }
         
         /// <inheritdoc />
         public override void FromRgb24(
             Configuration configuration,
-            ReadOnlySpan<Rgb24> sourcePixels,
-            Span<Abgr32> destinationPixels)
+            ReadOnlySpan<Rgb24> source,
+            Span<Abgr32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ReadOnlySpan<byte> source = MemoryMarshal.Cast<Rgb24, byte>(sourcePixels);
-            Span<byte> dest = MemoryMarshal.Cast<Abgr32, byte>(destinationPixels);
-            PixelConverter.FromRgb24.ToAbgr32(source, dest);
+            ReadOnlySpan<byte> sourceBytes = MemoryMarshal.Cast<Rgb24, byte>(source);
+            Span<byte> destinationBytes = MemoryMarshal.Cast<Abgr32, byte>(destination);
+            PixelConverter.FromRgb24.ToAbgr32(sourceBytes, destinationBytes);
         }        
     
         /// <inheritdoc />
         public override void ToBgr24(
             Configuration configuration,
-            ReadOnlySpan<Abgr32> sourcePixels,
-            Span<Bgr24> destinationPixels)
+            ReadOnlySpan<Abgr32> source,
+            Span<Bgr24> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ReadOnlySpan<byte> source = MemoryMarshal.Cast<Abgr32, byte>(sourcePixels);
-            Span<byte> dest = MemoryMarshal.Cast<Bgr24, byte>(destinationPixels);
-            PixelConverter.FromAbgr32.ToBgr24(source, dest);
+            ReadOnlySpan<byte> sourceBytes = MemoryMarshal.Cast<Abgr32, byte>(source);
+            Span<byte> destinationBytes = MemoryMarshal.Cast<Bgr24, byte>(destination);
+            PixelConverter.FromAbgr32.ToBgr24(sourceBytes, destinationBytes);
         }
         
         /// <inheritdoc />
         public override void FromBgr24(
             Configuration configuration,
-            ReadOnlySpan<Bgr24> sourcePixels,
-            Span<Abgr32> destinationPixels)
+            ReadOnlySpan<Bgr24> source,
+            Span<Abgr32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ReadOnlySpan<byte> source = MemoryMarshal.Cast<Bgr24, byte>(sourcePixels);
-            Span<byte> dest = MemoryMarshal.Cast<Abgr32, byte>(destinationPixels);
-            PixelConverter.FromBgr24.ToAbgr32(source, dest);
+            ReadOnlySpan<byte> sourceBytes = MemoryMarshal.Cast<Bgr24, byte>(source);
+            Span<byte> destinationBytes = MemoryMarshal.Cast<Abgr32, byte>(destination);
+            PixelConverter.FromBgr24.ToAbgr32(sourceBytes, destinationBytes);
         }        
 
         /// <inheritdoc />
         public override void ToL8(
             Configuration configuration,
-            ReadOnlySpan<Abgr32> sourcePixels,
-            Span<L8> destinationPixels)
+            ReadOnlySpan<Abgr32> source,
+            Span<L8> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref Abgr32 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref L8 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref Abgr32 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref L8 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref Abgr32 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref L8 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromAbgr32(sp);
+                Unsafe.Add(ref destinationBase, i) = L8.FromAbgr32(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToL16(
             Configuration configuration,
-            ReadOnlySpan<Abgr32> sourcePixels,
-            Span<L16> destinationPixels)
+            ReadOnlySpan<Abgr32> source,
+            Span<L16> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref Abgr32 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref L16 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref Abgr32 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref L16 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref Abgr32 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref L16 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromAbgr32(sp);
+                Unsafe.Add(ref destinationBase, i) = L16.FromAbgr32(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToLa16(
             Configuration configuration,
-            ReadOnlySpan<Abgr32> sourcePixels,
-            Span<La16> destinationPixels)
+            ReadOnlySpan<Abgr32> source,
+            Span<La16> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref Abgr32 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref La16 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref Abgr32 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref La16 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref Abgr32 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref La16 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromAbgr32(sp);
+                Unsafe.Add(ref destinationBase, i) = La16.FromAbgr32(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToLa32(
             Configuration configuration,
-            ReadOnlySpan<Abgr32> sourcePixels,
-            Span<La32> destinationPixels)
+            ReadOnlySpan<Abgr32> source,
+            Span<La32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref Abgr32 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref La32 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref Abgr32 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref La32 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref Abgr32 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref La32 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromAbgr32(sp);
+                Unsafe.Add(ref destinationBase, i) = La32.FromAbgr32(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToRgb48(
             Configuration configuration,
-            ReadOnlySpan<Abgr32> sourcePixels,
-            Span<Rgb48> destinationPixels)
+            ReadOnlySpan<Abgr32> source,
+            Span<Rgb48> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref Abgr32 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref Rgb48 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref Abgr32 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref Rgb48 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref Abgr32 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref Rgb48 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromAbgr32(sp);
+                Unsafe.Add(ref destinationBase, i) = Rgb48.FromAbgr32(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToRgba64(
             Configuration configuration,
-            ReadOnlySpan<Abgr32> sourcePixels,
-            Span<Rgba64> destinationPixels)
+            ReadOnlySpan<Abgr32> source,
+            Span<Rgba64> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref Abgr32 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref Rgba64 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref Abgr32 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref Rgba64 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref Abgr32 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref Rgba64 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromAbgr32(sp);
+                Unsafe.Add(ref destinationBase, i) = Rgba64.FromAbgr32(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToBgra5551(
             Configuration configuration,
-            ReadOnlySpan<Abgr32> sourcePixels,
-            Span<Bgra5551> destinationPixels)
+            ReadOnlySpan<Abgr32> source,
+            Span<Bgra5551> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref Abgr32 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref Bgra5551 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref Abgr32 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref Bgra5551 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref Abgr32 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref Bgra5551 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromAbgr32(sp);
+                Unsafe.Add(ref destinationBase, i) = Bgra5551.FromAbgr32(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void From<TSourcePixel>(
             Configuration configuration,
-            ReadOnlySpan<TSourcePixel> sourcePixels,
-            Span<Abgr32> destinationPixels)
+            ReadOnlySpan<TSourcePixel> source,
+            Span<Abgr32> destination)
         {
-            PixelOperations<TSourcePixel>.Instance.ToAbgr32(configuration, sourcePixels, destinationPixels.Slice(0, sourcePixels.Length));
+            PixelOperations<TSourcePixel>.Instance.ToAbgr32(configuration, source, destination.Slice(0, source.Length));
         }
     }
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Generated/Argb32.PixelOperations.Generated.cs b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Generated/Argb32.PixelOperations.Generated.cs
index 37ac39a85..30fed8d1c 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Generated/Argb32.PixelOperations.Generated.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Generated/Argb32.PixelOperations.Generated.cs
@@ -21,337 +21,316 @@ public partial struct Argb32
     internal partial class PixelOperations : PixelOperations<Argb32>
     {
         /// <inheritdoc />
-        public override void FromArgb32(Configuration configuration, ReadOnlySpan<Argb32> source, Span<Argb32> destinationPixels)
+        public override void FromArgb32(Configuration configuration, ReadOnlySpan<Argb32> source, Span<Argb32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(source, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            source.CopyTo(destinationPixels.Slice(0, source.Length));
+            source.CopyTo(destination.Slice(0, source.Length));
         }
 
         /// <inheritdoc />
-        public override void ToArgb32(Configuration configuration, ReadOnlySpan<Argb32> sourcePixels, Span<Argb32> destinationPixels)
+        public override void ToArgb32(Configuration configuration, ReadOnlySpan<Argb32> source, Span<Argb32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            sourcePixels.CopyTo(destinationPixels.Slice(0, sourcePixels.Length));
+            source.CopyTo(destination.Slice(0, source.Length));
         }
 
         /// <inheritdoc />
         public override void FromVector4Destructive(
             Configuration configuration,
             Span<Vector4> sourceVectors,
-            Span<Argb32> destinationPixels,
+            Span<Argb32> destination,
             PixelConversionModifiers modifiers)
         {
-            Vector4Converters.RgbaCompatible.FromVector4(configuration, this, sourceVectors, destinationPixels, modifiers.Remove(PixelConversionModifiers.Scale));
+            Vector4Converters.RgbaCompatible.FromVector4(configuration, this, sourceVectors, destination, modifiers.Remove(PixelConversionModifiers.Scale));
         }
 
         /// <inheritdoc />
         public override void ToVector4(
             Configuration configuration,
-            ReadOnlySpan<Argb32> sourcePixels,
-            Span<Vector4> destVectors,
+            ReadOnlySpan<Argb32> source,
+            Span<Vector4> destination,
             PixelConversionModifiers modifiers)
         {
-            Vector4Converters.RgbaCompatible.ToVector4(configuration, this, sourcePixels, destVectors, modifiers.Remove(PixelConversionModifiers.Scale));
+            Vector4Converters.RgbaCompatible.ToVector4(configuration, this, source, destination, modifiers.Remove(PixelConversionModifiers.Scale));
         }
     
         /// <inheritdoc />
         public override void ToRgba32(
             Configuration configuration,
-            ReadOnlySpan<Argb32> sourcePixels,
-            Span<Rgba32> destinationPixels)
+            ReadOnlySpan<Argb32> source,
+            Span<Rgba32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ReadOnlySpan<byte> source = MemoryMarshal.Cast<Argb32, byte>(sourcePixels);
-            Span<byte> dest = MemoryMarshal.Cast<Rgba32, byte>(destinationPixels);
-            PixelConverter.FromArgb32.ToRgba32(source, dest);
+            ReadOnlySpan<byte> sourceBytes = MemoryMarshal.Cast<Argb32, byte>(source);
+            Span<byte> destinationBytes = MemoryMarshal.Cast<Rgba32, byte>(destination);
+            PixelConverter.FromArgb32.ToRgba32(sourceBytes, destinationBytes);
         }
         
         /// <inheritdoc />
         public override void FromRgba32(
             Configuration configuration,
-            ReadOnlySpan<Rgba32> sourcePixels,
-            Span<Argb32> destinationPixels)
+            ReadOnlySpan<Rgba32> source,
+            Span<Argb32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ReadOnlySpan<byte> source = MemoryMarshal.Cast<Rgba32, byte>(sourcePixels);
-            Span<byte> dest = MemoryMarshal.Cast<Argb32, byte>(destinationPixels);
-            PixelConverter.FromRgba32.ToArgb32(source, dest);
+            ReadOnlySpan<byte> sourceBytes = MemoryMarshal.Cast<Rgba32, byte>(source);
+            Span<byte> destinationBytes = MemoryMarshal.Cast<Argb32, byte>(destination);
+            PixelConverter.FromRgba32.ToArgb32(sourceBytes, destinationBytes);
         }        
     
         /// <inheritdoc />
         public override void ToAbgr32(
             Configuration configuration,
-            ReadOnlySpan<Argb32> sourcePixels,
-            Span<Abgr32> destinationPixels)
+            ReadOnlySpan<Argb32> source,
+            Span<Abgr32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ReadOnlySpan<byte> source = MemoryMarshal.Cast<Argb32, byte>(sourcePixels);
-            Span<byte> dest = MemoryMarshal.Cast<Abgr32, byte>(destinationPixels);
-            PixelConverter.FromArgb32.ToAbgr32(source, dest);
+            ReadOnlySpan<byte> sourceBytes = MemoryMarshal.Cast<Argb32, byte>(source);
+            Span<byte> destinationBytes = MemoryMarshal.Cast<Abgr32, byte>(destination);
+            PixelConverter.FromArgb32.ToAbgr32(sourceBytes, destinationBytes);
         }
         
         /// <inheritdoc />
         public override void FromAbgr32(
             Configuration configuration,
-            ReadOnlySpan<Abgr32> sourcePixels,
-            Span<Argb32> destinationPixels)
+            ReadOnlySpan<Abgr32> source,
+            Span<Argb32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ReadOnlySpan<byte> source = MemoryMarshal.Cast<Abgr32, byte>(sourcePixels);
-            Span<byte> dest = MemoryMarshal.Cast<Argb32, byte>(destinationPixels);
-            PixelConverter.FromAbgr32.ToArgb32(source, dest);
+            ReadOnlySpan<byte> sourceBytes = MemoryMarshal.Cast<Abgr32, byte>(source);
+            Span<byte> destinationBytes = MemoryMarshal.Cast<Argb32, byte>(destination);
+            PixelConverter.FromAbgr32.ToArgb32(sourceBytes, destinationBytes);
         }        
     
         /// <inheritdoc />
         public override void ToBgra32(
             Configuration configuration,
-            ReadOnlySpan<Argb32> sourcePixels,
-            Span<Bgra32> destinationPixels)
+            ReadOnlySpan<Argb32> source,
+            Span<Bgra32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ReadOnlySpan<byte> source = MemoryMarshal.Cast<Argb32, byte>(sourcePixels);
-            Span<byte> dest = MemoryMarshal.Cast<Bgra32, byte>(destinationPixels);
-            PixelConverter.FromArgb32.ToBgra32(source, dest);
+            ReadOnlySpan<byte> sourceBytes = MemoryMarshal.Cast<Argb32, byte>(source);
+            Span<byte> destinationBytes = MemoryMarshal.Cast<Bgra32, byte>(destination);
+            PixelConverter.FromArgb32.ToBgra32(sourceBytes, destinationBytes);
         }
         
         /// <inheritdoc />
         public override void FromBgra32(
             Configuration configuration,
-            ReadOnlySpan<Bgra32> sourcePixels,
-            Span<Argb32> destinationPixels)
+            ReadOnlySpan<Bgra32> source,
+            Span<Argb32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ReadOnlySpan<byte> source = MemoryMarshal.Cast<Bgra32, byte>(sourcePixels);
-            Span<byte> dest = MemoryMarshal.Cast<Argb32, byte>(destinationPixels);
-            PixelConverter.FromBgra32.ToArgb32(source, dest);
+            ReadOnlySpan<byte> sourceBytes = MemoryMarshal.Cast<Bgra32, byte>(source);
+            Span<byte> destinationBytes = MemoryMarshal.Cast<Argb32, byte>(destination);
+            PixelConverter.FromBgra32.ToArgb32(sourceBytes, destinationBytes);
         }        
     
         /// <inheritdoc />
         public override void ToRgb24(
             Configuration configuration,
-            ReadOnlySpan<Argb32> sourcePixels,
-            Span<Rgb24> destinationPixels)
+            ReadOnlySpan<Argb32> source,
+            Span<Rgb24> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ReadOnlySpan<byte> source = MemoryMarshal.Cast<Argb32, byte>(sourcePixels);
-            Span<byte> dest = MemoryMarshal.Cast<Rgb24, byte>(destinationPixels);
-            PixelConverter.FromArgb32.ToRgb24(source, dest);
+            ReadOnlySpan<byte> sourceBytes = MemoryMarshal.Cast<Argb32, byte>(source);
+            Span<byte> destinationBytes = MemoryMarshal.Cast<Rgb24, byte>(destination);
+            PixelConverter.FromArgb32.ToRgb24(sourceBytes, destinationBytes);
         }
         
         /// <inheritdoc />
         public override void FromRgb24(
             Configuration configuration,
-            ReadOnlySpan<Rgb24> sourcePixels,
-            Span<Argb32> destinationPixels)
+            ReadOnlySpan<Rgb24> source,
+            Span<Argb32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ReadOnlySpan<byte> source = MemoryMarshal.Cast<Rgb24, byte>(sourcePixels);
-            Span<byte> dest = MemoryMarshal.Cast<Argb32, byte>(destinationPixels);
-            PixelConverter.FromRgb24.ToArgb32(source, dest);
+            ReadOnlySpan<byte> sourceBytes = MemoryMarshal.Cast<Rgb24, byte>(source);
+            Span<byte> destinationBytes = MemoryMarshal.Cast<Argb32, byte>(destination);
+            PixelConverter.FromRgb24.ToArgb32(sourceBytes, destinationBytes);
         }        
     
         /// <inheritdoc />
         public override void ToBgr24(
             Configuration configuration,
-            ReadOnlySpan<Argb32> sourcePixels,
-            Span<Bgr24> destinationPixels)
+            ReadOnlySpan<Argb32> source,
+            Span<Bgr24> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ReadOnlySpan<byte> source = MemoryMarshal.Cast<Argb32, byte>(sourcePixels);
-            Span<byte> dest = MemoryMarshal.Cast<Bgr24, byte>(destinationPixels);
-            PixelConverter.FromArgb32.ToBgr24(source, dest);
+            ReadOnlySpan<byte> sourceBytes = MemoryMarshal.Cast<Argb32, byte>(source);
+            Span<byte> destinationBytes = MemoryMarshal.Cast<Bgr24, byte>(destination);
+            PixelConverter.FromArgb32.ToBgr24(sourceBytes, destinationBytes);
         }
         
         /// <inheritdoc />
         public override void FromBgr24(
             Configuration configuration,
-            ReadOnlySpan<Bgr24> sourcePixels,
-            Span<Argb32> destinationPixels)
+            ReadOnlySpan<Bgr24> source,
+            Span<Argb32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ReadOnlySpan<byte> source = MemoryMarshal.Cast<Bgr24, byte>(sourcePixels);
-            Span<byte> dest = MemoryMarshal.Cast<Argb32, byte>(destinationPixels);
-            PixelConverter.FromBgr24.ToArgb32(source, dest);
+            ReadOnlySpan<byte> sourceBytes = MemoryMarshal.Cast<Bgr24, byte>(source);
+            Span<byte> destinationBytes = MemoryMarshal.Cast<Argb32, byte>(destination);
+            PixelConverter.FromBgr24.ToArgb32(sourceBytes, destinationBytes);
         }        
 
         /// <inheritdoc />
         public override void ToL8(
             Configuration configuration,
-            ReadOnlySpan<Argb32> sourcePixels,
-            Span<L8> destinationPixels)
+            ReadOnlySpan<Argb32> source,
+            Span<L8> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref Argb32 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref L8 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref Argb32 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref L8 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref Argb32 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref L8 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromArgb32(sp);
+                Unsafe.Add(ref destinationBase, i) = L8.FromArgb32(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToL16(
             Configuration configuration,
-            ReadOnlySpan<Argb32> sourcePixels,
-            Span<L16> destinationPixels)
+            ReadOnlySpan<Argb32> source,
+            Span<L16> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref Argb32 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref L16 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref Argb32 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref L16 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref Argb32 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref L16 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromArgb32(sp);
+                Unsafe.Add(ref destinationBase, i) = L16.FromArgb32(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToLa16(
             Configuration configuration,
-            ReadOnlySpan<Argb32> sourcePixels,
-            Span<La16> destinationPixels)
+            ReadOnlySpan<Argb32> source,
+            Span<La16> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref Argb32 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref La16 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref Argb32 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref La16 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref Argb32 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref La16 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromArgb32(sp);
+                Unsafe.Add(ref destinationBase, i) = La16.FromArgb32(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToLa32(
             Configuration configuration,
-            ReadOnlySpan<Argb32> sourcePixels,
-            Span<La32> destinationPixels)
+            ReadOnlySpan<Argb32> source,
+            Span<La32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref Argb32 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref La32 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref Argb32 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref La32 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref Argb32 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref La32 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromArgb32(sp);
+                Unsafe.Add(ref destinationBase, i) = La32.FromArgb32(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToRgb48(
             Configuration configuration,
-            ReadOnlySpan<Argb32> sourcePixels,
-            Span<Rgb48> destinationPixels)
+            ReadOnlySpan<Argb32> source,
+            Span<Rgb48> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref Argb32 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref Rgb48 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref Argb32 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref Rgb48 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref Argb32 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref Rgb48 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromArgb32(sp);
+                Unsafe.Add(ref destinationBase, i) = Rgb48.FromArgb32(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToRgba64(
             Configuration configuration,
-            ReadOnlySpan<Argb32> sourcePixels,
-            Span<Rgba64> destinationPixels)
+            ReadOnlySpan<Argb32> source,
+            Span<Rgba64> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref Argb32 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref Rgba64 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref Argb32 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref Rgba64 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref Argb32 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref Rgba64 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromArgb32(sp);
+                Unsafe.Add(ref destinationBase, i) = Rgba64.FromArgb32(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToBgra5551(
             Configuration configuration,
-            ReadOnlySpan<Argb32> sourcePixels,
-            Span<Bgra5551> destinationPixels)
+            ReadOnlySpan<Argb32> source,
+            Span<Bgra5551> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref Argb32 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref Bgra5551 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref Argb32 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref Bgra5551 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref Argb32 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref Bgra5551 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromArgb32(sp);
+                Unsafe.Add(ref destinationBase, i) = Bgra5551.FromArgb32(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void From<TSourcePixel>(
             Configuration configuration,
-            ReadOnlySpan<TSourcePixel> sourcePixels,
-            Span<Argb32> destinationPixels)
+            ReadOnlySpan<TSourcePixel> source,
+            Span<Argb32> destination)
         {
-            PixelOperations<TSourcePixel>.Instance.ToArgb32(configuration, sourcePixels, destinationPixels.Slice(0, sourcePixels.Length));
+            PixelOperations<TSourcePixel>.Instance.ToArgb32(configuration, source, destination.Slice(0, source.Length));
         }
     }
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Generated/Bgr24.PixelOperations.Generated.cs b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Generated/Bgr24.PixelOperations.Generated.cs
index f604d6f97..e3ff3a7fe 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Generated/Bgr24.PixelOperations.Generated.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Generated/Bgr24.PixelOperations.Generated.cs
@@ -21,337 +21,316 @@ public partial struct Bgr24
     internal partial class PixelOperations : PixelOperations<Bgr24>
     {
         /// <inheritdoc />
-        public override void FromBgr24(Configuration configuration, ReadOnlySpan<Bgr24> source, Span<Bgr24> destinationPixels)
+        public override void FromBgr24(Configuration configuration, ReadOnlySpan<Bgr24> source, Span<Bgr24> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(source, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            source.CopyTo(destinationPixels.Slice(0, source.Length));
+            source.CopyTo(destination.Slice(0, source.Length));
         }
 
         /// <inheritdoc />
-        public override void ToBgr24(Configuration configuration, ReadOnlySpan<Bgr24> sourcePixels, Span<Bgr24> destinationPixels)
+        public override void ToBgr24(Configuration configuration, ReadOnlySpan<Bgr24> source, Span<Bgr24> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            sourcePixels.CopyTo(destinationPixels.Slice(0, sourcePixels.Length));
+            source.CopyTo(destination.Slice(0, source.Length));
         }
 
         /// <inheritdoc />
         public override void FromVector4Destructive(
             Configuration configuration,
             Span<Vector4> sourceVectors,
-            Span<Bgr24> destinationPixels,
+            Span<Bgr24> destination,
             PixelConversionModifiers modifiers)
         {
-            Vector4Converters.RgbaCompatible.FromVector4(configuration, this, sourceVectors, destinationPixels, modifiers.Remove(PixelConversionModifiers.Scale | PixelConversionModifiers.Premultiply));
+            Vector4Converters.RgbaCompatible.FromVector4(configuration, this, sourceVectors, destination, modifiers.Remove(PixelConversionModifiers.Scale | PixelConversionModifiers.Premultiply));
         }
 
         /// <inheritdoc />
         public override void ToVector4(
             Configuration configuration,
-            ReadOnlySpan<Bgr24> sourcePixels,
-            Span<Vector4> destVectors,
+            ReadOnlySpan<Bgr24> source,
+            Span<Vector4> destination,
             PixelConversionModifiers modifiers)
         {
-            Vector4Converters.RgbaCompatible.ToVector4(configuration, this, sourcePixels, destVectors, modifiers.Remove(PixelConversionModifiers.Scale | PixelConversionModifiers.Premultiply));
+            Vector4Converters.RgbaCompatible.ToVector4(configuration, this, source, destination, modifiers.Remove(PixelConversionModifiers.Scale | PixelConversionModifiers.Premultiply));
         }
     
         /// <inheritdoc />
         public override void ToRgba32(
             Configuration configuration,
-            ReadOnlySpan<Bgr24> sourcePixels,
-            Span<Rgba32> destinationPixels)
+            ReadOnlySpan<Bgr24> source,
+            Span<Rgba32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ReadOnlySpan<byte> source = MemoryMarshal.Cast<Bgr24, byte>(sourcePixels);
-            Span<byte> dest = MemoryMarshal.Cast<Rgba32, byte>(destinationPixels);
-            PixelConverter.FromBgr24.ToRgba32(source, dest);
+            ReadOnlySpan<byte> sourceBytes = MemoryMarshal.Cast<Bgr24, byte>(source);
+            Span<byte> destinationBytes = MemoryMarshal.Cast<Rgba32, byte>(destination);
+            PixelConverter.FromBgr24.ToRgba32(sourceBytes, destinationBytes);
         }
         
         /// <inheritdoc />
         public override void FromRgba32(
             Configuration configuration,
-            ReadOnlySpan<Rgba32> sourcePixels,
-            Span<Bgr24> destinationPixels)
+            ReadOnlySpan<Rgba32> source,
+            Span<Bgr24> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ReadOnlySpan<byte> source = MemoryMarshal.Cast<Rgba32, byte>(sourcePixels);
-            Span<byte> dest = MemoryMarshal.Cast<Bgr24, byte>(destinationPixels);
-            PixelConverter.FromRgba32.ToBgr24(source, dest);
+            ReadOnlySpan<byte> sourceBytes = MemoryMarshal.Cast<Rgba32, byte>(source);
+            Span<byte> destinationBytes = MemoryMarshal.Cast<Bgr24, byte>(destination);
+            PixelConverter.FromRgba32.ToBgr24(sourceBytes, destinationBytes);
         }        
     
         /// <inheritdoc />
         public override void ToArgb32(
             Configuration configuration,
-            ReadOnlySpan<Bgr24> sourcePixels,
-            Span<Argb32> destinationPixels)
+            ReadOnlySpan<Bgr24> source,
+            Span<Argb32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ReadOnlySpan<byte> source = MemoryMarshal.Cast<Bgr24, byte>(sourcePixels);
-            Span<byte> dest = MemoryMarshal.Cast<Argb32, byte>(destinationPixels);
-            PixelConverter.FromBgr24.ToArgb32(source, dest);
+            ReadOnlySpan<byte> sourceBytes = MemoryMarshal.Cast<Bgr24, byte>(source);
+            Span<byte> destinationBytes = MemoryMarshal.Cast<Argb32, byte>(destination);
+            PixelConverter.FromBgr24.ToArgb32(sourceBytes, destinationBytes);
         }
         
         /// <inheritdoc />
         public override void FromArgb32(
             Configuration configuration,
-            ReadOnlySpan<Argb32> sourcePixels,
-            Span<Bgr24> destinationPixels)
+            ReadOnlySpan<Argb32> source,
+            Span<Bgr24> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ReadOnlySpan<byte> source = MemoryMarshal.Cast<Argb32, byte>(sourcePixels);
-            Span<byte> dest = MemoryMarshal.Cast<Bgr24, byte>(destinationPixels);
-            PixelConverter.FromArgb32.ToBgr24(source, dest);
+            ReadOnlySpan<byte> sourceBytes = MemoryMarshal.Cast<Argb32, byte>(source);
+            Span<byte> destinationBytes = MemoryMarshal.Cast<Bgr24, byte>(destination);
+            PixelConverter.FromArgb32.ToBgr24(sourceBytes, destinationBytes);
         }        
     
         /// <inheritdoc />
         public override void ToAbgr32(
             Configuration configuration,
-            ReadOnlySpan<Bgr24> sourcePixels,
-            Span<Abgr32> destinationPixels)
+            ReadOnlySpan<Bgr24> source,
+            Span<Abgr32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ReadOnlySpan<byte> source = MemoryMarshal.Cast<Bgr24, byte>(sourcePixels);
-            Span<byte> dest = MemoryMarshal.Cast<Abgr32, byte>(destinationPixels);
-            PixelConverter.FromBgr24.ToAbgr32(source, dest);
+            ReadOnlySpan<byte> sourceBytes = MemoryMarshal.Cast<Bgr24, byte>(source);
+            Span<byte> destinationBytes = MemoryMarshal.Cast<Abgr32, byte>(destination);
+            PixelConverter.FromBgr24.ToAbgr32(sourceBytes, destinationBytes);
         }
         
         /// <inheritdoc />
         public override void FromAbgr32(
             Configuration configuration,
-            ReadOnlySpan<Abgr32> sourcePixels,
-            Span<Bgr24> destinationPixels)
+            ReadOnlySpan<Abgr32> source,
+            Span<Bgr24> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ReadOnlySpan<byte> source = MemoryMarshal.Cast<Abgr32, byte>(sourcePixels);
-            Span<byte> dest = MemoryMarshal.Cast<Bgr24, byte>(destinationPixels);
-            PixelConverter.FromAbgr32.ToBgr24(source, dest);
+            ReadOnlySpan<byte> sourceBytes = MemoryMarshal.Cast<Abgr32, byte>(source);
+            Span<byte> destinationBytes = MemoryMarshal.Cast<Bgr24, byte>(destination);
+            PixelConverter.FromAbgr32.ToBgr24(sourceBytes, destinationBytes);
         }        
     
         /// <inheritdoc />
         public override void ToBgra32(
             Configuration configuration,
-            ReadOnlySpan<Bgr24> sourcePixels,
-            Span<Bgra32> destinationPixels)
+            ReadOnlySpan<Bgr24> source,
+            Span<Bgra32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ReadOnlySpan<byte> source = MemoryMarshal.Cast<Bgr24, byte>(sourcePixels);
-            Span<byte> dest = MemoryMarshal.Cast<Bgra32, byte>(destinationPixels);
-            PixelConverter.FromBgr24.ToBgra32(source, dest);
+            ReadOnlySpan<byte> sourceBytes = MemoryMarshal.Cast<Bgr24, byte>(source);
+            Span<byte> destinationBytes = MemoryMarshal.Cast<Bgra32, byte>(destination);
+            PixelConverter.FromBgr24.ToBgra32(sourceBytes, destinationBytes);
         }
         
         /// <inheritdoc />
         public override void FromBgra32(
             Configuration configuration,
-            ReadOnlySpan<Bgra32> sourcePixels,
-            Span<Bgr24> destinationPixels)
+            ReadOnlySpan<Bgra32> source,
+            Span<Bgr24> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ReadOnlySpan<byte> source = MemoryMarshal.Cast<Bgra32, byte>(sourcePixels);
-            Span<byte> dest = MemoryMarshal.Cast<Bgr24, byte>(destinationPixels);
-            PixelConverter.FromBgra32.ToBgr24(source, dest);
+            ReadOnlySpan<byte> sourceBytes = MemoryMarshal.Cast<Bgra32, byte>(source);
+            Span<byte> destinationBytes = MemoryMarshal.Cast<Bgr24, byte>(destination);
+            PixelConverter.FromBgra32.ToBgr24(sourceBytes, destinationBytes);
         }        
     
         /// <inheritdoc />
         public override void ToRgb24(
             Configuration configuration,
-            ReadOnlySpan<Bgr24> sourcePixels,
-            Span<Rgb24> destinationPixels)
+            ReadOnlySpan<Bgr24> source,
+            Span<Rgb24> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ReadOnlySpan<byte> source = MemoryMarshal.Cast<Bgr24, byte>(sourcePixels);
-            Span<byte> dest = MemoryMarshal.Cast<Rgb24, byte>(destinationPixels);
-            PixelConverter.FromBgr24.ToRgb24(source, dest);
+            ReadOnlySpan<byte> sourceBytes = MemoryMarshal.Cast<Bgr24, byte>(source);
+            Span<byte> destinationBytes = MemoryMarshal.Cast<Rgb24, byte>(destination);
+            PixelConverter.FromBgr24.ToRgb24(sourceBytes, destinationBytes);
         }
         
         /// <inheritdoc />
         public override void FromRgb24(
             Configuration configuration,
-            ReadOnlySpan<Rgb24> sourcePixels,
-            Span<Bgr24> destinationPixels)
+            ReadOnlySpan<Rgb24> source,
+            Span<Bgr24> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ReadOnlySpan<byte> source = MemoryMarshal.Cast<Rgb24, byte>(sourcePixels);
-            Span<byte> dest = MemoryMarshal.Cast<Bgr24, byte>(destinationPixels);
-            PixelConverter.FromRgb24.ToBgr24(source, dest);
+            ReadOnlySpan<byte> sourceBytes = MemoryMarshal.Cast<Rgb24, byte>(source);
+            Span<byte> destinationBytes = MemoryMarshal.Cast<Bgr24, byte>(destination);
+            PixelConverter.FromRgb24.ToBgr24(sourceBytes, destinationBytes);
         }        
 
         /// <inheritdoc />
         public override void ToL8(
             Configuration configuration,
-            ReadOnlySpan<Bgr24> sourcePixels,
-            Span<L8> destinationPixels)
+            ReadOnlySpan<Bgr24> source,
+            Span<L8> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref Bgr24 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref L8 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref Bgr24 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref L8 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref Bgr24 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref L8 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromBgr24(sp);
+                Unsafe.Add(ref destinationBase, i) = L8.FromBgr24(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToL16(
             Configuration configuration,
-            ReadOnlySpan<Bgr24> sourcePixels,
-            Span<L16> destinationPixels)
+            ReadOnlySpan<Bgr24> source,
+            Span<L16> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref Bgr24 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref L16 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref Bgr24 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref L16 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref Bgr24 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref L16 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromBgr24(sp);
+                Unsafe.Add(ref destinationBase, i) = L16.FromBgr24(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToLa16(
             Configuration configuration,
-            ReadOnlySpan<Bgr24> sourcePixels,
-            Span<La16> destinationPixels)
+            ReadOnlySpan<Bgr24> source,
+            Span<La16> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref Bgr24 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref La16 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref Bgr24 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref La16 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref Bgr24 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref La16 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromBgr24(sp);
+                Unsafe.Add(ref destinationBase, i) = La16.FromBgr24(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToLa32(
             Configuration configuration,
-            ReadOnlySpan<Bgr24> sourcePixels,
-            Span<La32> destinationPixels)
+            ReadOnlySpan<Bgr24> source,
+            Span<La32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref Bgr24 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref La32 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref Bgr24 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref La32 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref Bgr24 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref La32 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromBgr24(sp);
+                Unsafe.Add(ref destinationBase, i) = La32.FromBgr24(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToRgb48(
             Configuration configuration,
-            ReadOnlySpan<Bgr24> sourcePixels,
-            Span<Rgb48> destinationPixels)
+            ReadOnlySpan<Bgr24> source,
+            Span<Rgb48> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref Bgr24 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref Rgb48 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref Bgr24 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref Rgb48 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref Bgr24 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref Rgb48 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromBgr24(sp);
+                Unsafe.Add(ref destinationBase, i) = Rgb48.FromBgr24(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToRgba64(
             Configuration configuration,
-            ReadOnlySpan<Bgr24> sourcePixels,
-            Span<Rgba64> destinationPixels)
+            ReadOnlySpan<Bgr24> source,
+            Span<Rgba64> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref Bgr24 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref Rgba64 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref Bgr24 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref Rgba64 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref Bgr24 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref Rgba64 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromBgr24(sp);
+                Unsafe.Add(ref destinationBase, i) = Rgba64.FromBgr24(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToBgra5551(
             Configuration configuration,
-            ReadOnlySpan<Bgr24> sourcePixels,
-            Span<Bgra5551> destinationPixels)
+            ReadOnlySpan<Bgr24> source,
+            Span<Bgra5551> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref Bgr24 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref Bgra5551 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref Bgr24 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref Bgra5551 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref Bgr24 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref Bgra5551 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromBgr24(sp);
+                Unsafe.Add(ref destinationBase, i) = Bgra5551.FromBgr24(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void From<TSourcePixel>(
             Configuration configuration,
-            ReadOnlySpan<TSourcePixel> sourcePixels,
-            Span<Bgr24> destinationPixels)
+            ReadOnlySpan<TSourcePixel> source,
+            Span<Bgr24> destination)
         {
-            PixelOperations<TSourcePixel>.Instance.ToBgr24(configuration, sourcePixels, destinationPixels.Slice(0, sourcePixels.Length));
+            PixelOperations<TSourcePixel>.Instance.ToBgr24(configuration, source, destination.Slice(0, source.Length));
         }
     }
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Generated/Bgra32.PixelOperations.Generated.cs b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Generated/Bgra32.PixelOperations.Generated.cs
index b9f7a49e1..ae6be4401 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Generated/Bgra32.PixelOperations.Generated.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Generated/Bgra32.PixelOperations.Generated.cs
@@ -21,337 +21,316 @@ public partial struct Bgra32
     internal partial class PixelOperations : PixelOperations<Bgra32>
     {
         /// <inheritdoc />
-        public override void FromBgra32(Configuration configuration, ReadOnlySpan<Bgra32> source, Span<Bgra32> destinationPixels)
+        public override void FromBgra32(Configuration configuration, ReadOnlySpan<Bgra32> source, Span<Bgra32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(source, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            source.CopyTo(destinationPixels.Slice(0, source.Length));
+            source.CopyTo(destination.Slice(0, source.Length));
         }
 
         /// <inheritdoc />
-        public override void ToBgra32(Configuration configuration, ReadOnlySpan<Bgra32> sourcePixels, Span<Bgra32> destinationPixels)
+        public override void ToBgra32(Configuration configuration, ReadOnlySpan<Bgra32> source, Span<Bgra32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            sourcePixels.CopyTo(destinationPixels.Slice(0, sourcePixels.Length));
+            source.CopyTo(destination.Slice(0, source.Length));
         }
 
         /// <inheritdoc />
         public override void FromVector4Destructive(
             Configuration configuration,
             Span<Vector4> sourceVectors,
-            Span<Bgra32> destinationPixels,
+            Span<Bgra32> destination,
             PixelConversionModifiers modifiers)
         {
-            Vector4Converters.RgbaCompatible.FromVector4(configuration, this, sourceVectors, destinationPixels, modifiers.Remove(PixelConversionModifiers.Scale));
+            Vector4Converters.RgbaCompatible.FromVector4(configuration, this, sourceVectors, destination, modifiers.Remove(PixelConversionModifiers.Scale));
         }
 
         /// <inheritdoc />
         public override void ToVector4(
             Configuration configuration,
-            ReadOnlySpan<Bgra32> sourcePixels,
-            Span<Vector4> destVectors,
+            ReadOnlySpan<Bgra32> source,
+            Span<Vector4> destination,
             PixelConversionModifiers modifiers)
         {
-            Vector4Converters.RgbaCompatible.ToVector4(configuration, this, sourcePixels, destVectors, modifiers.Remove(PixelConversionModifiers.Scale));
+            Vector4Converters.RgbaCompatible.ToVector4(configuration, this, source, destination, modifiers.Remove(PixelConversionModifiers.Scale));
         }
     
         /// <inheritdoc />
         public override void ToRgba32(
             Configuration configuration,
-            ReadOnlySpan<Bgra32> sourcePixels,
-            Span<Rgba32> destinationPixels)
+            ReadOnlySpan<Bgra32> source,
+            Span<Rgba32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ReadOnlySpan<byte> source = MemoryMarshal.Cast<Bgra32, byte>(sourcePixels);
-            Span<byte> dest = MemoryMarshal.Cast<Rgba32, byte>(destinationPixels);
-            PixelConverter.FromBgra32.ToRgba32(source, dest);
+            ReadOnlySpan<byte> sourceBytes = MemoryMarshal.Cast<Bgra32, byte>(source);
+            Span<byte> destinationBytes = MemoryMarshal.Cast<Rgba32, byte>(destination);
+            PixelConverter.FromBgra32.ToRgba32(sourceBytes, destinationBytes);
         }
         
         /// <inheritdoc />
         public override void FromRgba32(
             Configuration configuration,
-            ReadOnlySpan<Rgba32> sourcePixels,
-            Span<Bgra32> destinationPixels)
+            ReadOnlySpan<Rgba32> source,
+            Span<Bgra32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ReadOnlySpan<byte> source = MemoryMarshal.Cast<Rgba32, byte>(sourcePixels);
-            Span<byte> dest = MemoryMarshal.Cast<Bgra32, byte>(destinationPixels);
-            PixelConverter.FromRgba32.ToBgra32(source, dest);
+            ReadOnlySpan<byte> sourceBytes = MemoryMarshal.Cast<Rgba32, byte>(source);
+            Span<byte> destinationBytes = MemoryMarshal.Cast<Bgra32, byte>(destination);
+            PixelConverter.FromRgba32.ToBgra32(sourceBytes, destinationBytes);
         }        
     
         /// <inheritdoc />
         public override void ToArgb32(
             Configuration configuration,
-            ReadOnlySpan<Bgra32> sourcePixels,
-            Span<Argb32> destinationPixels)
+            ReadOnlySpan<Bgra32> source,
+            Span<Argb32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ReadOnlySpan<byte> source = MemoryMarshal.Cast<Bgra32, byte>(sourcePixels);
-            Span<byte> dest = MemoryMarshal.Cast<Argb32, byte>(destinationPixels);
-            PixelConverter.FromBgra32.ToArgb32(source, dest);
+            ReadOnlySpan<byte> sourceBytes = MemoryMarshal.Cast<Bgra32, byte>(source);
+            Span<byte> destinationBytes = MemoryMarshal.Cast<Argb32, byte>(destination);
+            PixelConverter.FromBgra32.ToArgb32(sourceBytes, destinationBytes);
         }
         
         /// <inheritdoc />
         public override void FromArgb32(
             Configuration configuration,
-            ReadOnlySpan<Argb32> sourcePixels,
-            Span<Bgra32> destinationPixels)
+            ReadOnlySpan<Argb32> source,
+            Span<Bgra32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ReadOnlySpan<byte> source = MemoryMarshal.Cast<Argb32, byte>(sourcePixels);
-            Span<byte> dest = MemoryMarshal.Cast<Bgra32, byte>(destinationPixels);
-            PixelConverter.FromArgb32.ToBgra32(source, dest);
+            ReadOnlySpan<byte> sourceBytes = MemoryMarshal.Cast<Argb32, byte>(source);
+            Span<byte> destinationBytes = MemoryMarshal.Cast<Bgra32, byte>(destination);
+            PixelConverter.FromArgb32.ToBgra32(sourceBytes, destinationBytes);
         }        
     
         /// <inheritdoc />
         public override void ToAbgr32(
             Configuration configuration,
-            ReadOnlySpan<Bgra32> sourcePixels,
-            Span<Abgr32> destinationPixels)
+            ReadOnlySpan<Bgra32> source,
+            Span<Abgr32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ReadOnlySpan<byte> source = MemoryMarshal.Cast<Bgra32, byte>(sourcePixels);
-            Span<byte> dest = MemoryMarshal.Cast<Abgr32, byte>(destinationPixels);
-            PixelConverter.FromBgra32.ToAbgr32(source, dest);
+            ReadOnlySpan<byte> sourceBytes = MemoryMarshal.Cast<Bgra32, byte>(source);
+            Span<byte> destinationBytes = MemoryMarshal.Cast<Abgr32, byte>(destination);
+            PixelConverter.FromBgra32.ToAbgr32(sourceBytes, destinationBytes);
         }
         
         /// <inheritdoc />
         public override void FromAbgr32(
             Configuration configuration,
-            ReadOnlySpan<Abgr32> sourcePixels,
-            Span<Bgra32> destinationPixels)
+            ReadOnlySpan<Abgr32> source,
+            Span<Bgra32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ReadOnlySpan<byte> source = MemoryMarshal.Cast<Abgr32, byte>(sourcePixels);
-            Span<byte> dest = MemoryMarshal.Cast<Bgra32, byte>(destinationPixels);
-            PixelConverter.FromAbgr32.ToBgra32(source, dest);
+            ReadOnlySpan<byte> sourceBytes = MemoryMarshal.Cast<Abgr32, byte>(source);
+            Span<byte> destinationBytes = MemoryMarshal.Cast<Bgra32, byte>(destination);
+            PixelConverter.FromAbgr32.ToBgra32(sourceBytes, destinationBytes);
         }        
     
         /// <inheritdoc />
         public override void ToRgb24(
             Configuration configuration,
-            ReadOnlySpan<Bgra32> sourcePixels,
-            Span<Rgb24> destinationPixels)
+            ReadOnlySpan<Bgra32> source,
+            Span<Rgb24> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ReadOnlySpan<byte> source = MemoryMarshal.Cast<Bgra32, byte>(sourcePixels);
-            Span<byte> dest = MemoryMarshal.Cast<Rgb24, byte>(destinationPixels);
-            PixelConverter.FromBgra32.ToRgb24(source, dest);
+            ReadOnlySpan<byte> sourceBytes = MemoryMarshal.Cast<Bgra32, byte>(source);
+            Span<byte> destinationBytes = MemoryMarshal.Cast<Rgb24, byte>(destination);
+            PixelConverter.FromBgra32.ToRgb24(sourceBytes, destinationBytes);
         }
         
         /// <inheritdoc />
         public override void FromRgb24(
             Configuration configuration,
-            ReadOnlySpan<Rgb24> sourcePixels,
-            Span<Bgra32> destinationPixels)
+            ReadOnlySpan<Rgb24> source,
+            Span<Bgra32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ReadOnlySpan<byte> source = MemoryMarshal.Cast<Rgb24, byte>(sourcePixels);
-            Span<byte> dest = MemoryMarshal.Cast<Bgra32, byte>(destinationPixels);
-            PixelConverter.FromRgb24.ToBgra32(source, dest);
+            ReadOnlySpan<byte> sourceBytes = MemoryMarshal.Cast<Rgb24, byte>(source);
+            Span<byte> destinationBytes = MemoryMarshal.Cast<Bgra32, byte>(destination);
+            PixelConverter.FromRgb24.ToBgra32(sourceBytes, destinationBytes);
         }        
     
         /// <inheritdoc />
         public override void ToBgr24(
             Configuration configuration,
-            ReadOnlySpan<Bgra32> sourcePixels,
-            Span<Bgr24> destinationPixels)
+            ReadOnlySpan<Bgra32> source,
+            Span<Bgr24> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ReadOnlySpan<byte> source = MemoryMarshal.Cast<Bgra32, byte>(sourcePixels);
-            Span<byte> dest = MemoryMarshal.Cast<Bgr24, byte>(destinationPixels);
-            PixelConverter.FromBgra32.ToBgr24(source, dest);
+            ReadOnlySpan<byte> sourceBytes = MemoryMarshal.Cast<Bgra32, byte>(source);
+            Span<byte> destinationBytes = MemoryMarshal.Cast<Bgr24, byte>(destination);
+            PixelConverter.FromBgra32.ToBgr24(sourceBytes, destinationBytes);
         }
         
         /// <inheritdoc />
         public override void FromBgr24(
             Configuration configuration,
-            ReadOnlySpan<Bgr24> sourcePixels,
-            Span<Bgra32> destinationPixels)
+            ReadOnlySpan<Bgr24> source,
+            Span<Bgra32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ReadOnlySpan<byte> source = MemoryMarshal.Cast<Bgr24, byte>(sourcePixels);
-            Span<byte> dest = MemoryMarshal.Cast<Bgra32, byte>(destinationPixels);
-            PixelConverter.FromBgr24.ToBgra32(source, dest);
+            ReadOnlySpan<byte> sourceBytes = MemoryMarshal.Cast<Bgr24, byte>(source);
+            Span<byte> destinationBytes = MemoryMarshal.Cast<Bgra32, byte>(destination);
+            PixelConverter.FromBgr24.ToBgra32(sourceBytes, destinationBytes);
         }        
 
         /// <inheritdoc />
         public override void ToL8(
             Configuration configuration,
-            ReadOnlySpan<Bgra32> sourcePixels,
-            Span<L8> destinationPixels)
+            ReadOnlySpan<Bgra32> source,
+            Span<L8> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref Bgra32 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref L8 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref Bgra32 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref L8 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref Bgra32 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref L8 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromBgra32(sp);
+                Unsafe.Add(ref destinationBase, i) = L8.FromBgra32(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToL16(
             Configuration configuration,
-            ReadOnlySpan<Bgra32> sourcePixels,
-            Span<L16> destinationPixels)
+            ReadOnlySpan<Bgra32> source,
+            Span<L16> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref Bgra32 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref L16 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref Bgra32 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref L16 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref Bgra32 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref L16 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromBgra32(sp);
+                Unsafe.Add(ref destinationBase, i) = L16.FromBgra32(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToLa16(
             Configuration configuration,
-            ReadOnlySpan<Bgra32> sourcePixels,
-            Span<La16> destinationPixels)
+            ReadOnlySpan<Bgra32> source,
+            Span<La16> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref Bgra32 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref La16 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref Bgra32 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref La16 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref Bgra32 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref La16 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromBgra32(sp);
+                Unsafe.Add(ref destinationBase, i) = La16.FromBgra32(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToLa32(
             Configuration configuration,
-            ReadOnlySpan<Bgra32> sourcePixels,
-            Span<La32> destinationPixels)
+            ReadOnlySpan<Bgra32> source,
+            Span<La32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref Bgra32 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref La32 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref Bgra32 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref La32 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref Bgra32 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref La32 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromBgra32(sp);
+                Unsafe.Add(ref destinationBase, i) = La32.FromBgra32(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToRgb48(
             Configuration configuration,
-            ReadOnlySpan<Bgra32> sourcePixels,
-            Span<Rgb48> destinationPixels)
+            ReadOnlySpan<Bgra32> source,
+            Span<Rgb48> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref Bgra32 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref Rgb48 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref Bgra32 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref Rgb48 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref Bgra32 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref Rgb48 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromBgra32(sp);
+                Unsafe.Add(ref destinationBase, i) = Rgb48.FromBgra32(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToRgba64(
             Configuration configuration,
-            ReadOnlySpan<Bgra32> sourcePixels,
-            Span<Rgba64> destinationPixels)
+            ReadOnlySpan<Bgra32> source,
+            Span<Rgba64> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref Bgra32 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref Rgba64 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref Bgra32 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref Rgba64 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref Bgra32 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref Rgba64 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromBgra32(sp);
+                Unsafe.Add(ref destinationBase, i) = Rgba64.FromBgra32(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToBgra5551(
             Configuration configuration,
-            ReadOnlySpan<Bgra32> sourcePixels,
-            Span<Bgra5551> destinationPixels)
+            ReadOnlySpan<Bgra32> source,
+            Span<Bgra5551> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref Bgra32 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref Bgra5551 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref Bgra32 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref Bgra5551 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref Bgra32 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref Bgra5551 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromBgra32(sp);
+                Unsafe.Add(ref destinationBase, i) = Bgra5551.FromBgra32(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void From<TSourcePixel>(
             Configuration configuration,
-            ReadOnlySpan<TSourcePixel> sourcePixels,
-            Span<Bgra32> destinationPixels)
+            ReadOnlySpan<TSourcePixel> source,
+            Span<Bgra32> destination)
         {
-            PixelOperations<TSourcePixel>.Instance.ToBgra32(configuration, sourcePixels, destinationPixels.Slice(0, sourcePixels.Length));
+            PixelOperations<TSourcePixel>.Instance.ToBgra32(configuration, source, destination.Slice(0, source.Length));
         }
     }
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Generated/Bgra5551.PixelOperations.Generated.cs b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Generated/Bgra5551.PixelOperations.Generated.cs
index c1ba4f061..9e877cb9d 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Generated/Bgra5551.PixelOperations.Generated.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Generated/Bgra5551.PixelOperations.Generated.cs
@@ -21,282 +21,246 @@ public partial struct Bgra5551
     internal partial class PixelOperations : PixelOperations<Bgra5551>
     {
         /// <inheritdoc />
-        public override void FromBgra5551(Configuration configuration, ReadOnlySpan<Bgra5551> source, Span<Bgra5551> destinationPixels)
+        public override void FromBgra5551(Configuration configuration, ReadOnlySpan<Bgra5551> source, Span<Bgra5551> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(source, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            source.CopyTo(destinationPixels.Slice(0, source.Length));
+            source.CopyTo(destination.Slice(0, source.Length));
         }
 
         /// <inheritdoc />
-        public override void ToBgra5551(Configuration configuration, ReadOnlySpan<Bgra5551> sourcePixels, Span<Bgra5551> destinationPixels)
+        public override void ToBgra5551(Configuration configuration, ReadOnlySpan<Bgra5551> source, Span<Bgra5551> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            sourcePixels.CopyTo(destinationPixels.Slice(0, sourcePixels.Length));
+            source.CopyTo(destination.Slice(0, source.Length));
         }
 
         /// <inheritdoc />
         public override void ToArgb32(
             Configuration configuration,
-            ReadOnlySpan<Bgra5551> sourcePixels,
-            Span<Argb32> destinationPixels)
+            ReadOnlySpan<Bgra5551> source,
+            Span<Argb32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref Bgra5551 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref Argb32 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref Bgra5551 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref Argb32 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref Bgra5551 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref Argb32 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromBgra5551(sp);
+                Unsafe.Add(ref destinationBase, i) = Argb32.FromBgra5551(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToAbgr32(
             Configuration configuration,
-            ReadOnlySpan<Bgra5551> sourcePixels,
-            Span<Abgr32> destinationPixels)
+            ReadOnlySpan<Bgra5551> source,
+            Span<Abgr32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref Bgra5551 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref Abgr32 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref Bgra5551 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref Abgr32 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref Bgra5551 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref Abgr32 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromBgra5551(sp);
+                Unsafe.Add(ref destinationBase, i) = Abgr32.FromBgra5551(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToBgr24(
             Configuration configuration,
-            ReadOnlySpan<Bgra5551> sourcePixels,
-            Span<Bgr24> destinationPixels)
+            ReadOnlySpan<Bgra5551> source,
+            Span<Bgr24> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref Bgra5551 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref Bgr24 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref Bgra5551 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref Bgr24 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref Bgra5551 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref Bgr24 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromBgra5551(sp);
+                Unsafe.Add(ref destinationBase, i) = Bgr24.FromBgra5551(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToBgra32(
             Configuration configuration,
-            ReadOnlySpan<Bgra5551> sourcePixels,
-            Span<Bgra32> destinationPixels)
+            ReadOnlySpan<Bgra5551> source,
+            Span<Bgra32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref Bgra5551 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref Bgra32 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref Bgra5551 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref Bgra32 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref Bgra5551 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref Bgra32 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromBgra5551(sp);
+                Unsafe.Add(ref destinationBase, i) = Bgra32.FromBgra5551(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToL8(
             Configuration configuration,
-            ReadOnlySpan<Bgra5551> sourcePixels,
-            Span<L8> destinationPixels)
+            ReadOnlySpan<Bgra5551> source,
+            Span<L8> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref Bgra5551 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref L8 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref Bgra5551 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref L8 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref Bgra5551 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref L8 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromBgra5551(sp);
+                Unsafe.Add(ref destinationBase, i) = L8.FromBgra5551(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToL16(
             Configuration configuration,
-            ReadOnlySpan<Bgra5551> sourcePixels,
-            Span<L16> destinationPixels)
+            ReadOnlySpan<Bgra5551> source,
+            Span<L16> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref Bgra5551 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref L16 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref Bgra5551 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref L16 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref Bgra5551 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref L16 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromBgra5551(sp);
+                Unsafe.Add(ref destinationBase, i) = L16.FromBgra5551(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToLa16(
             Configuration configuration,
-            ReadOnlySpan<Bgra5551> sourcePixels,
-            Span<La16> destinationPixels)
+            ReadOnlySpan<Bgra5551> source,
+            Span<La16> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref Bgra5551 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref La16 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref Bgra5551 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref La16 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref Bgra5551 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref La16 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromBgra5551(sp);
+                Unsafe.Add(ref destinationBase, i) = La16.FromBgra5551(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToLa32(
             Configuration configuration,
-            ReadOnlySpan<Bgra5551> sourcePixels,
-            Span<La32> destinationPixels)
+            ReadOnlySpan<Bgra5551> source,
+            Span<La32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref Bgra5551 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref La32 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref Bgra5551 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref La32 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref Bgra5551 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref La32 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromBgra5551(sp);
+                Unsafe.Add(ref destinationBase, i) = La32.FromBgra5551(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToRgb24(
             Configuration configuration,
-            ReadOnlySpan<Bgra5551> sourcePixels,
-            Span<Rgb24> destinationPixels)
+            ReadOnlySpan<Bgra5551> source,
+            Span<Rgb24> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref Bgra5551 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref Rgb24 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref Bgra5551 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref Rgb24 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref Bgra5551 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref Rgb24 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromBgra5551(sp);
+                Unsafe.Add(ref destinationBase, i) = Rgb24.FromBgra5551(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToRgba32(
             Configuration configuration,
-            ReadOnlySpan<Bgra5551> sourcePixels,
-            Span<Rgba32> destinationPixels)
+            ReadOnlySpan<Bgra5551> source,
+            Span<Rgba32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref Bgra5551 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref Rgba32 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref Bgra5551 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref Rgba32 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref Bgra5551 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref Rgba32 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromBgra5551(sp);
+                Unsafe.Add(ref destinationBase, i) = Rgba32.FromBgra5551(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToRgb48(
             Configuration configuration,
-            ReadOnlySpan<Bgra5551> sourcePixels,
-            Span<Rgb48> destinationPixels)
+            ReadOnlySpan<Bgra5551> source,
+            Span<Rgb48> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref Bgra5551 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref Rgb48 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref Bgra5551 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref Rgb48 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref Bgra5551 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref Rgb48 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromBgra5551(sp);
+                Unsafe.Add(ref destinationBase, i) = Rgb48.FromBgra5551(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToRgba64(
             Configuration configuration,
-            ReadOnlySpan<Bgra5551> sourcePixels,
-            Span<Rgba64> destinationPixels)
+            ReadOnlySpan<Bgra5551> source,
+            Span<Rgba64> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref Bgra5551 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref Rgba64 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref Bgra5551 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref Rgba64 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref Bgra5551 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref Rgba64 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromBgra5551(sp);
+                Unsafe.Add(ref destinationBase, i) = Rgba64.FromBgra5551(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void From<TSourcePixel>(
             Configuration configuration,
-            ReadOnlySpan<TSourcePixel> sourcePixels,
-            Span<Bgra5551> destinationPixels)
+            ReadOnlySpan<TSourcePixel> source,
+            Span<Bgra5551> destination)
         {
-            PixelOperations<TSourcePixel>.Instance.ToBgra5551(configuration, sourcePixels, destinationPixels.Slice(0, sourcePixels.Length));
+            PixelOperations<TSourcePixel>.Instance.ToBgra5551(configuration, source, destination.Slice(0, source.Length));
         }
     }
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Generated/L16.PixelOperations.Generated.cs b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Generated/L16.PixelOperations.Generated.cs
index c38d752ea..21c782456 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Generated/L16.PixelOperations.Generated.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Generated/L16.PixelOperations.Generated.cs
@@ -21,282 +21,246 @@ public partial struct L16
     internal partial class PixelOperations : PixelOperations<L16>
     {
         /// <inheritdoc />
-        public override void FromL16(Configuration configuration, ReadOnlySpan<L16> source, Span<L16> destinationPixels)
+        public override void FromL16(Configuration configuration, ReadOnlySpan<L16> source, Span<L16> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(source, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            source.CopyTo(destinationPixels.Slice(0, source.Length));
+            source.CopyTo(destination.Slice(0, source.Length));
         }
 
         /// <inheritdoc />
-        public override void ToL16(Configuration configuration, ReadOnlySpan<L16> sourcePixels, Span<L16> destinationPixels)
+        public override void ToL16(Configuration configuration, ReadOnlySpan<L16> source, Span<L16> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            sourcePixels.CopyTo(destinationPixels.Slice(0, sourcePixels.Length));
+            source.CopyTo(destination.Slice(0, source.Length));
         }
 
         /// <inheritdoc />
         public override void ToArgb32(
             Configuration configuration,
-            ReadOnlySpan<L16> sourcePixels,
-            Span<Argb32> destinationPixels)
+            ReadOnlySpan<L16> source,
+            Span<Argb32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref L16 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref Argb32 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref L16 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref Argb32 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref L16 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref Argb32 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromL16(sp);
+                Unsafe.Add(ref destinationBase, i) = Argb32.FromL16(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToAbgr32(
             Configuration configuration,
-            ReadOnlySpan<L16> sourcePixels,
-            Span<Abgr32> destinationPixels)
+            ReadOnlySpan<L16> source,
+            Span<Abgr32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref L16 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref Abgr32 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref L16 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref Abgr32 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref L16 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref Abgr32 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromL16(sp);
+                Unsafe.Add(ref destinationBase, i) = Abgr32.FromL16(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToBgr24(
             Configuration configuration,
-            ReadOnlySpan<L16> sourcePixels,
-            Span<Bgr24> destinationPixels)
+            ReadOnlySpan<L16> source,
+            Span<Bgr24> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref L16 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref Bgr24 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref L16 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref Bgr24 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref L16 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref Bgr24 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromL16(sp);
+                Unsafe.Add(ref destinationBase, i) = Bgr24.FromL16(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToBgra32(
             Configuration configuration,
-            ReadOnlySpan<L16> sourcePixels,
-            Span<Bgra32> destinationPixels)
+            ReadOnlySpan<L16> source,
+            Span<Bgra32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref L16 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref Bgra32 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref L16 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref Bgra32 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref L16 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref Bgra32 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromL16(sp);
+                Unsafe.Add(ref destinationBase, i) = Bgra32.FromL16(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToL8(
             Configuration configuration,
-            ReadOnlySpan<L16> sourcePixels,
-            Span<L8> destinationPixels)
+            ReadOnlySpan<L16> source,
+            Span<L8> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref L16 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref L8 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref L16 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref L8 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref L16 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref L8 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromL16(sp);
+                Unsafe.Add(ref destinationBase, i) = L8.FromL16(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToLa16(
             Configuration configuration,
-            ReadOnlySpan<L16> sourcePixels,
-            Span<La16> destinationPixels)
+            ReadOnlySpan<L16> source,
+            Span<La16> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref L16 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref La16 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref L16 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref La16 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref L16 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref La16 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromL16(sp);
+                Unsafe.Add(ref destinationBase, i) = La16.FromL16(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToLa32(
             Configuration configuration,
-            ReadOnlySpan<L16> sourcePixels,
-            Span<La32> destinationPixels)
+            ReadOnlySpan<L16> source,
+            Span<La32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref L16 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref La32 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref L16 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref La32 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref L16 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref La32 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromL16(sp);
+                Unsafe.Add(ref destinationBase, i) = La32.FromL16(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToRgb24(
             Configuration configuration,
-            ReadOnlySpan<L16> sourcePixels,
-            Span<Rgb24> destinationPixels)
+            ReadOnlySpan<L16> source,
+            Span<Rgb24> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref L16 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref Rgb24 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref L16 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref Rgb24 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref L16 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref Rgb24 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromL16(sp);
+                Unsafe.Add(ref destinationBase, i) = Rgb24.FromL16(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToRgba32(
             Configuration configuration,
-            ReadOnlySpan<L16> sourcePixels,
-            Span<Rgba32> destinationPixels)
+            ReadOnlySpan<L16> source,
+            Span<Rgba32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref L16 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref Rgba32 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref L16 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref Rgba32 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref L16 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref Rgba32 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromL16(sp);
+                Unsafe.Add(ref destinationBase, i) = Rgba32.FromL16(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToRgb48(
             Configuration configuration,
-            ReadOnlySpan<L16> sourcePixels,
-            Span<Rgb48> destinationPixels)
+            ReadOnlySpan<L16> source,
+            Span<Rgb48> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref L16 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref Rgb48 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref L16 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref Rgb48 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref L16 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref Rgb48 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromL16(sp);
+                Unsafe.Add(ref destinationBase, i) = Rgb48.FromL16(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToRgba64(
             Configuration configuration,
-            ReadOnlySpan<L16> sourcePixels,
-            Span<Rgba64> destinationPixels)
+            ReadOnlySpan<L16> source,
+            Span<Rgba64> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref L16 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref Rgba64 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref L16 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref Rgba64 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref L16 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref Rgba64 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromL16(sp);
+                Unsafe.Add(ref destinationBase, i) = Rgba64.FromL16(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToBgra5551(
             Configuration configuration,
-            ReadOnlySpan<L16> sourcePixels,
-            Span<Bgra5551> destinationPixels)
+            ReadOnlySpan<L16> source,
+            Span<Bgra5551> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref L16 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref Bgra5551 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref L16 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref Bgra5551 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref L16 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref Bgra5551 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromL16(sp);
+                Unsafe.Add(ref destinationBase, i) = Bgra5551.FromL16(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void From<TSourcePixel>(
             Configuration configuration,
-            ReadOnlySpan<TSourcePixel> sourcePixels,
-            Span<L16> destinationPixels)
+            ReadOnlySpan<TSourcePixel> source,
+            Span<L16> destination)
         {
-            PixelOperations<TSourcePixel>.Instance.ToL16(configuration, sourcePixels, destinationPixels.Slice(0, sourcePixels.Length));
+            PixelOperations<TSourcePixel>.Instance.ToL16(configuration, source, destination.Slice(0, source.Length));
         }
     }
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Generated/L8.PixelOperations.Generated.cs b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Generated/L8.PixelOperations.Generated.cs
index 656a0546b..6a7c45800 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Generated/L8.PixelOperations.Generated.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Generated/L8.PixelOperations.Generated.cs
@@ -21,282 +21,246 @@ public partial struct L8
     internal partial class PixelOperations : PixelOperations<L8>
     {
         /// <inheritdoc />
-        public override void FromL8(Configuration configuration, ReadOnlySpan<L8> source, Span<L8> destinationPixels)
+        public override void FromL8(Configuration configuration, ReadOnlySpan<L8> source, Span<L8> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(source, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            source.CopyTo(destinationPixels.Slice(0, source.Length));
+            source.CopyTo(destination.Slice(0, source.Length));
         }
 
         /// <inheritdoc />
-        public override void ToL8(Configuration configuration, ReadOnlySpan<L8> sourcePixels, Span<L8> destinationPixels)
+        public override void ToL8(Configuration configuration, ReadOnlySpan<L8> source, Span<L8> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            sourcePixels.CopyTo(destinationPixels.Slice(0, sourcePixels.Length));
+            source.CopyTo(destination.Slice(0, source.Length));
         }
 
         /// <inheritdoc />
         public override void ToArgb32(
             Configuration configuration,
-            ReadOnlySpan<L8> sourcePixels,
-            Span<Argb32> destinationPixels)
+            ReadOnlySpan<L8> source,
+            Span<Argb32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref L8 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref Argb32 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref L8 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref Argb32 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref L8 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref Argb32 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromL8(sp);
+                Unsafe.Add(ref destinationBase, i) = Argb32.FromL8(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToAbgr32(
             Configuration configuration,
-            ReadOnlySpan<L8> sourcePixels,
-            Span<Abgr32> destinationPixels)
+            ReadOnlySpan<L8> source,
+            Span<Abgr32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref L8 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref Abgr32 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref L8 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref Abgr32 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref L8 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref Abgr32 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromL8(sp);
+                Unsafe.Add(ref destinationBase, i) = Abgr32.FromL8(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToBgr24(
             Configuration configuration,
-            ReadOnlySpan<L8> sourcePixels,
-            Span<Bgr24> destinationPixels)
+            ReadOnlySpan<L8> source,
+            Span<Bgr24> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref L8 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref Bgr24 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref L8 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref Bgr24 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref L8 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref Bgr24 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromL8(sp);
+                Unsafe.Add(ref destinationBase, i) = Bgr24.FromL8(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToBgra32(
             Configuration configuration,
-            ReadOnlySpan<L8> sourcePixels,
-            Span<Bgra32> destinationPixels)
+            ReadOnlySpan<L8> source,
+            Span<Bgra32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref L8 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref Bgra32 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref L8 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref Bgra32 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref L8 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref Bgra32 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromL8(sp);
+                Unsafe.Add(ref destinationBase, i) = Bgra32.FromL8(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToL16(
             Configuration configuration,
-            ReadOnlySpan<L8> sourcePixels,
-            Span<L16> destinationPixels)
+            ReadOnlySpan<L8> source,
+            Span<L16> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref L8 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref L16 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref L8 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref L16 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref L8 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref L16 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromL8(sp);
+                Unsafe.Add(ref destinationBase, i) = L16.FromL8(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToLa16(
             Configuration configuration,
-            ReadOnlySpan<L8> sourcePixels,
-            Span<La16> destinationPixels)
+            ReadOnlySpan<L8> source,
+            Span<La16> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref L8 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref La16 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref L8 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref La16 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref L8 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref La16 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromL8(sp);
+                Unsafe.Add(ref destinationBase, i) = La16.FromL8(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToLa32(
             Configuration configuration,
-            ReadOnlySpan<L8> sourcePixels,
-            Span<La32> destinationPixels)
+            ReadOnlySpan<L8> source,
+            Span<La32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref L8 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref La32 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref L8 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref La32 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref L8 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref La32 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromL8(sp);
+                Unsafe.Add(ref destinationBase, i) = La32.FromL8(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToRgb24(
             Configuration configuration,
-            ReadOnlySpan<L8> sourcePixels,
-            Span<Rgb24> destinationPixels)
+            ReadOnlySpan<L8> source,
+            Span<Rgb24> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref L8 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref Rgb24 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref L8 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref Rgb24 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref L8 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref Rgb24 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromL8(sp);
+                Unsafe.Add(ref destinationBase, i) = Rgb24.FromL8(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToRgba32(
             Configuration configuration,
-            ReadOnlySpan<L8> sourcePixels,
-            Span<Rgba32> destinationPixels)
+            ReadOnlySpan<L8> source,
+            Span<Rgba32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref L8 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref Rgba32 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref L8 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref Rgba32 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref L8 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref Rgba32 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromL8(sp);
+                Unsafe.Add(ref destinationBase, i) = Rgba32.FromL8(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToRgb48(
             Configuration configuration,
-            ReadOnlySpan<L8> sourcePixels,
-            Span<Rgb48> destinationPixels)
+            ReadOnlySpan<L8> source,
+            Span<Rgb48> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref L8 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref Rgb48 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref L8 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref Rgb48 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref L8 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref Rgb48 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromL8(sp);
+                Unsafe.Add(ref destinationBase, i) = Rgb48.FromL8(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToRgba64(
             Configuration configuration,
-            ReadOnlySpan<L8> sourcePixels,
-            Span<Rgba64> destinationPixels)
+            ReadOnlySpan<L8> source,
+            Span<Rgba64> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref L8 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref Rgba64 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref L8 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref Rgba64 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref L8 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref Rgba64 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromL8(sp);
+                Unsafe.Add(ref destinationBase, i) = Rgba64.FromL8(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToBgra5551(
             Configuration configuration,
-            ReadOnlySpan<L8> sourcePixels,
-            Span<Bgra5551> destinationPixels)
+            ReadOnlySpan<L8> source,
+            Span<Bgra5551> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref L8 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref Bgra5551 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref L8 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref Bgra5551 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref L8 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref Bgra5551 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromL8(sp);
+                Unsafe.Add(ref destinationBase, i) = Bgra5551.FromL8(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void From<TSourcePixel>(
             Configuration configuration,
-            ReadOnlySpan<TSourcePixel> sourcePixels,
-            Span<L8> destinationPixels)
+            ReadOnlySpan<TSourcePixel> source,
+            Span<L8> destination)
         {
-            PixelOperations<TSourcePixel>.Instance.ToL8(configuration, sourcePixels, destinationPixels.Slice(0, sourcePixels.Length));
+            PixelOperations<TSourcePixel>.Instance.ToL8(configuration, source, destination.Slice(0, source.Length));
         }
     }
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Generated/La16.PixelOperations.Generated.cs b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Generated/La16.PixelOperations.Generated.cs
index 82be1323c..2346f32e1 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Generated/La16.PixelOperations.Generated.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Generated/La16.PixelOperations.Generated.cs
@@ -21,282 +21,246 @@ public partial struct La16
     internal partial class PixelOperations : PixelOperations<La16>
     {
         /// <inheritdoc />
-        public override void FromLa16(Configuration configuration, ReadOnlySpan<La16> source, Span<La16> destinationPixels)
+        public override void FromLa16(Configuration configuration, ReadOnlySpan<La16> source, Span<La16> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(source, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            source.CopyTo(destinationPixels.Slice(0, source.Length));
+            source.CopyTo(destination.Slice(0, source.Length));
         }
 
         /// <inheritdoc />
-        public override void ToLa16(Configuration configuration, ReadOnlySpan<La16> sourcePixels, Span<La16> destinationPixels)
+        public override void ToLa16(Configuration configuration, ReadOnlySpan<La16> source, Span<La16> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            sourcePixels.CopyTo(destinationPixels.Slice(0, sourcePixels.Length));
+            source.CopyTo(destination.Slice(0, source.Length));
         }
 
         /// <inheritdoc />
         public override void ToArgb32(
             Configuration configuration,
-            ReadOnlySpan<La16> sourcePixels,
-            Span<Argb32> destinationPixels)
+            ReadOnlySpan<La16> source,
+            Span<Argb32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref La16 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref Argb32 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref La16 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref Argb32 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref La16 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref Argb32 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromLa16(sp);
+                Unsafe.Add(ref destinationBase, i) = Argb32.FromLa16(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToAbgr32(
             Configuration configuration,
-            ReadOnlySpan<La16> sourcePixels,
-            Span<Abgr32> destinationPixels)
+            ReadOnlySpan<La16> source,
+            Span<Abgr32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref La16 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref Abgr32 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref La16 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref Abgr32 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref La16 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref Abgr32 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromLa16(sp);
+                Unsafe.Add(ref destinationBase, i) = Abgr32.FromLa16(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToBgr24(
             Configuration configuration,
-            ReadOnlySpan<La16> sourcePixels,
-            Span<Bgr24> destinationPixels)
+            ReadOnlySpan<La16> source,
+            Span<Bgr24> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref La16 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref Bgr24 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref La16 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref Bgr24 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref La16 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref Bgr24 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromLa16(sp);
+                Unsafe.Add(ref destinationBase, i) = Bgr24.FromLa16(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToBgra32(
             Configuration configuration,
-            ReadOnlySpan<La16> sourcePixels,
-            Span<Bgra32> destinationPixels)
+            ReadOnlySpan<La16> source,
+            Span<Bgra32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref La16 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref Bgra32 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref La16 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref Bgra32 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref La16 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref Bgra32 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromLa16(sp);
+                Unsafe.Add(ref destinationBase, i) = Bgra32.FromLa16(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToL8(
             Configuration configuration,
-            ReadOnlySpan<La16> sourcePixels,
-            Span<L8> destinationPixels)
+            ReadOnlySpan<La16> source,
+            Span<L8> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref La16 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref L8 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref La16 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref L8 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref La16 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref L8 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromLa16(sp);
+                Unsafe.Add(ref destinationBase, i) = L8.FromLa16(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToL16(
             Configuration configuration,
-            ReadOnlySpan<La16> sourcePixels,
-            Span<L16> destinationPixels)
+            ReadOnlySpan<La16> source,
+            Span<L16> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref La16 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref L16 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref La16 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref L16 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref La16 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref L16 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromLa16(sp);
+                Unsafe.Add(ref destinationBase, i) = L16.FromLa16(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToLa32(
             Configuration configuration,
-            ReadOnlySpan<La16> sourcePixels,
-            Span<La32> destinationPixels)
+            ReadOnlySpan<La16> source,
+            Span<La32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref La16 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref La32 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref La16 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref La32 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref La16 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref La32 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromLa16(sp);
+                Unsafe.Add(ref destinationBase, i) = La32.FromLa16(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToRgb24(
             Configuration configuration,
-            ReadOnlySpan<La16> sourcePixels,
-            Span<Rgb24> destinationPixels)
+            ReadOnlySpan<La16> source,
+            Span<Rgb24> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref La16 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref Rgb24 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref La16 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref Rgb24 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref La16 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref Rgb24 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromLa16(sp);
+                Unsafe.Add(ref destinationBase, i) = Rgb24.FromLa16(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToRgba32(
             Configuration configuration,
-            ReadOnlySpan<La16> sourcePixels,
-            Span<Rgba32> destinationPixels)
+            ReadOnlySpan<La16> source,
+            Span<Rgba32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref La16 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref Rgba32 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref La16 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref Rgba32 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref La16 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref Rgba32 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromLa16(sp);
+                Unsafe.Add(ref destinationBase, i) = Rgba32.FromLa16(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToRgb48(
             Configuration configuration,
-            ReadOnlySpan<La16> sourcePixels,
-            Span<Rgb48> destinationPixels)
+            ReadOnlySpan<La16> source,
+            Span<Rgb48> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref La16 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref Rgb48 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref La16 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref Rgb48 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref La16 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref Rgb48 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromLa16(sp);
+                Unsafe.Add(ref destinationBase, i) = Rgb48.FromLa16(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToRgba64(
             Configuration configuration,
-            ReadOnlySpan<La16> sourcePixels,
-            Span<Rgba64> destinationPixels)
+            ReadOnlySpan<La16> source,
+            Span<Rgba64> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref La16 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref Rgba64 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref La16 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref Rgba64 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref La16 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref Rgba64 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromLa16(sp);
+                Unsafe.Add(ref destinationBase, i) = Rgba64.FromLa16(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToBgra5551(
             Configuration configuration,
-            ReadOnlySpan<La16> sourcePixels,
-            Span<Bgra5551> destinationPixels)
+            ReadOnlySpan<La16> source,
+            Span<Bgra5551> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref La16 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref Bgra5551 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref La16 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref Bgra5551 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref La16 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref Bgra5551 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromLa16(sp);
+                Unsafe.Add(ref destinationBase, i) = Bgra5551.FromLa16(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void From<TSourcePixel>(
             Configuration configuration,
-            ReadOnlySpan<TSourcePixel> sourcePixels,
-            Span<La16> destinationPixels)
+            ReadOnlySpan<TSourcePixel> source,
+            Span<La16> destination)
         {
-            PixelOperations<TSourcePixel>.Instance.ToLa16(configuration, sourcePixels, destinationPixels.Slice(0, sourcePixels.Length));
+            PixelOperations<TSourcePixel>.Instance.ToLa16(configuration, source, destination.Slice(0, source.Length));
         }
     }
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Generated/La32.PixelOperations.Generated.cs b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Generated/La32.PixelOperations.Generated.cs
index a9ee9d6b7..d949d61e0 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Generated/La32.PixelOperations.Generated.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Generated/La32.PixelOperations.Generated.cs
@@ -21,282 +21,246 @@ public partial struct La32
     internal partial class PixelOperations : PixelOperations<La32>
     {
         /// <inheritdoc />
-        public override void FromLa32(Configuration configuration, ReadOnlySpan<La32> source, Span<La32> destinationPixels)
+        public override void FromLa32(Configuration configuration, ReadOnlySpan<La32> source, Span<La32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(source, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            source.CopyTo(destinationPixels.Slice(0, source.Length));
+            source.CopyTo(destination.Slice(0, source.Length));
         }
 
         /// <inheritdoc />
-        public override void ToLa32(Configuration configuration, ReadOnlySpan<La32> sourcePixels, Span<La32> destinationPixels)
+        public override void ToLa32(Configuration configuration, ReadOnlySpan<La32> source, Span<La32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            sourcePixels.CopyTo(destinationPixels.Slice(0, sourcePixels.Length));
+            source.CopyTo(destination.Slice(0, source.Length));
         }
 
         /// <inheritdoc />
         public override void ToArgb32(
             Configuration configuration,
-            ReadOnlySpan<La32> sourcePixels,
-            Span<Argb32> destinationPixels)
+            ReadOnlySpan<La32> source,
+            Span<Argb32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref La32 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref Argb32 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref La32 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref Argb32 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref La32 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref Argb32 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromLa32(sp);
+                Unsafe.Add(ref destinationBase, i) = Argb32.FromLa32(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToAbgr32(
             Configuration configuration,
-            ReadOnlySpan<La32> sourcePixels,
-            Span<Abgr32> destinationPixels)
+            ReadOnlySpan<La32> source,
+            Span<Abgr32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref La32 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref Abgr32 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref La32 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref Abgr32 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref La32 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref Abgr32 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromLa32(sp);
+                Unsafe.Add(ref destinationBase, i) = Abgr32.FromLa32(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToBgr24(
             Configuration configuration,
-            ReadOnlySpan<La32> sourcePixels,
-            Span<Bgr24> destinationPixels)
+            ReadOnlySpan<La32> source,
+            Span<Bgr24> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref La32 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref Bgr24 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref La32 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref Bgr24 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref La32 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref Bgr24 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromLa32(sp);
+                Unsafe.Add(ref destinationBase, i) = Bgr24.FromLa32(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToBgra32(
             Configuration configuration,
-            ReadOnlySpan<La32> sourcePixels,
-            Span<Bgra32> destinationPixels)
+            ReadOnlySpan<La32> source,
+            Span<Bgra32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref La32 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref Bgra32 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref La32 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref Bgra32 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref La32 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref Bgra32 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromLa32(sp);
+                Unsafe.Add(ref destinationBase, i) = Bgra32.FromLa32(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToL8(
             Configuration configuration,
-            ReadOnlySpan<La32> sourcePixels,
-            Span<L8> destinationPixels)
+            ReadOnlySpan<La32> source,
+            Span<L8> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref La32 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref L8 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref La32 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref L8 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref La32 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref L8 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromLa32(sp);
+                Unsafe.Add(ref destinationBase, i) = L8.FromLa32(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToL16(
             Configuration configuration,
-            ReadOnlySpan<La32> sourcePixels,
-            Span<L16> destinationPixels)
+            ReadOnlySpan<La32> source,
+            Span<L16> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref La32 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref L16 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref La32 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref L16 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref La32 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref L16 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromLa32(sp);
+                Unsafe.Add(ref destinationBase, i) = L16.FromLa32(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToLa16(
             Configuration configuration,
-            ReadOnlySpan<La32> sourcePixels,
-            Span<La16> destinationPixels)
+            ReadOnlySpan<La32> source,
+            Span<La16> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref La32 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref La16 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref La32 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref La16 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref La32 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref La16 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromLa32(sp);
+                Unsafe.Add(ref destinationBase, i) = La16.FromLa32(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToRgb24(
             Configuration configuration,
-            ReadOnlySpan<La32> sourcePixels,
-            Span<Rgb24> destinationPixels)
+            ReadOnlySpan<La32> source,
+            Span<Rgb24> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref La32 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref Rgb24 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref La32 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref Rgb24 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref La32 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref Rgb24 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromLa32(sp);
+                Unsafe.Add(ref destinationBase, i) = Rgb24.FromLa32(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToRgba32(
             Configuration configuration,
-            ReadOnlySpan<La32> sourcePixels,
-            Span<Rgba32> destinationPixels)
+            ReadOnlySpan<La32> source,
+            Span<Rgba32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref La32 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref Rgba32 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref La32 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref Rgba32 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref La32 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref Rgba32 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromLa32(sp);
+                Unsafe.Add(ref destinationBase, i) = Rgba32.FromLa32(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToRgb48(
             Configuration configuration,
-            ReadOnlySpan<La32> sourcePixels,
-            Span<Rgb48> destinationPixels)
+            ReadOnlySpan<La32> source,
+            Span<Rgb48> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref La32 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref Rgb48 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref La32 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref Rgb48 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref La32 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref Rgb48 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromLa32(sp);
+                Unsafe.Add(ref destinationBase, i) = Rgb48.FromLa32(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToRgba64(
             Configuration configuration,
-            ReadOnlySpan<La32> sourcePixels,
-            Span<Rgba64> destinationPixels)
+            ReadOnlySpan<La32> source,
+            Span<Rgba64> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref La32 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref Rgba64 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref La32 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref Rgba64 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref La32 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref Rgba64 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromLa32(sp);
+                Unsafe.Add(ref destinationBase, i) = Rgba64.FromLa32(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToBgra5551(
             Configuration configuration,
-            ReadOnlySpan<La32> sourcePixels,
-            Span<Bgra5551> destinationPixels)
+            ReadOnlySpan<La32> source,
+            Span<Bgra5551> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref La32 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref Bgra5551 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref La32 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref Bgra5551 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref La32 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref Bgra5551 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromLa32(sp);
+                Unsafe.Add(ref destinationBase, i) = Bgra5551.FromLa32(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void From<TSourcePixel>(
             Configuration configuration,
-            ReadOnlySpan<TSourcePixel> sourcePixels,
-            Span<La32> destinationPixels)
+            ReadOnlySpan<TSourcePixel> source,
+            Span<La32> destination)
         {
-            PixelOperations<TSourcePixel>.Instance.ToLa32(configuration, sourcePixels, destinationPixels.Slice(0, sourcePixels.Length));
+            PixelOperations<TSourcePixel>.Instance.ToLa32(configuration, source, destination.Slice(0, source.Length));
         }
     }
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Generated/Rgb24.PixelOperations.Generated.cs b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Generated/Rgb24.PixelOperations.Generated.cs
index 1d87121e9..fd6465a22 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Generated/Rgb24.PixelOperations.Generated.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Generated/Rgb24.PixelOperations.Generated.cs
@@ -21,337 +21,316 @@ public partial struct Rgb24
     internal partial class PixelOperations : PixelOperations<Rgb24>
     {
         /// <inheritdoc />
-        public override void FromRgb24(Configuration configuration, ReadOnlySpan<Rgb24> source, Span<Rgb24> destinationPixels)
+        public override void FromRgb24(Configuration configuration, ReadOnlySpan<Rgb24> source, Span<Rgb24> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(source, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            source.CopyTo(destinationPixels.Slice(0, source.Length));
+            source.CopyTo(destination.Slice(0, source.Length));
         }
 
         /// <inheritdoc />
-        public override void ToRgb24(Configuration configuration, ReadOnlySpan<Rgb24> sourcePixels, Span<Rgb24> destinationPixels)
+        public override void ToRgb24(Configuration configuration, ReadOnlySpan<Rgb24> source, Span<Rgb24> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            sourcePixels.CopyTo(destinationPixels.Slice(0, sourcePixels.Length));
+            source.CopyTo(destination.Slice(0, source.Length));
         }
 
         /// <inheritdoc />
         public override void FromVector4Destructive(
             Configuration configuration,
             Span<Vector4> sourceVectors,
-            Span<Rgb24> destinationPixels,
+            Span<Rgb24> destination,
             PixelConversionModifiers modifiers)
         {
-            Vector4Converters.RgbaCompatible.FromVector4(configuration, this, sourceVectors, destinationPixels, modifiers.Remove(PixelConversionModifiers.Scale | PixelConversionModifiers.Premultiply));
+            Vector4Converters.RgbaCompatible.FromVector4(configuration, this, sourceVectors, destination, modifiers.Remove(PixelConversionModifiers.Scale | PixelConversionModifiers.Premultiply));
         }
 
         /// <inheritdoc />
         public override void ToVector4(
             Configuration configuration,
-            ReadOnlySpan<Rgb24> sourcePixels,
-            Span<Vector4> destVectors,
+            ReadOnlySpan<Rgb24> source,
+            Span<Vector4> destination,
             PixelConversionModifiers modifiers)
         {
-            Vector4Converters.RgbaCompatible.ToVector4(configuration, this, sourcePixels, destVectors, modifiers.Remove(PixelConversionModifiers.Scale | PixelConversionModifiers.Premultiply));
+            Vector4Converters.RgbaCompatible.ToVector4(configuration, this, source, destination, modifiers.Remove(PixelConversionModifiers.Scale | PixelConversionModifiers.Premultiply));
         }
     
         /// <inheritdoc />
         public override void ToRgba32(
             Configuration configuration,
-            ReadOnlySpan<Rgb24> sourcePixels,
-            Span<Rgba32> destinationPixels)
+            ReadOnlySpan<Rgb24> source,
+            Span<Rgba32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ReadOnlySpan<byte> source = MemoryMarshal.Cast<Rgb24, byte>(sourcePixels);
-            Span<byte> dest = MemoryMarshal.Cast<Rgba32, byte>(destinationPixels);
-            PixelConverter.FromRgb24.ToRgba32(source, dest);
+            ReadOnlySpan<byte> sourceBytes = MemoryMarshal.Cast<Rgb24, byte>(source);
+            Span<byte> destinationBytes = MemoryMarshal.Cast<Rgba32, byte>(destination);
+            PixelConverter.FromRgb24.ToRgba32(sourceBytes, destinationBytes);
         }
         
         /// <inheritdoc />
         public override void FromRgba32(
             Configuration configuration,
-            ReadOnlySpan<Rgba32> sourcePixels,
-            Span<Rgb24> destinationPixels)
+            ReadOnlySpan<Rgba32> source,
+            Span<Rgb24> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ReadOnlySpan<byte> source = MemoryMarshal.Cast<Rgba32, byte>(sourcePixels);
-            Span<byte> dest = MemoryMarshal.Cast<Rgb24, byte>(destinationPixels);
-            PixelConverter.FromRgba32.ToRgb24(source, dest);
+            ReadOnlySpan<byte> sourceBytes = MemoryMarshal.Cast<Rgba32, byte>(source);
+            Span<byte> destinationBytes = MemoryMarshal.Cast<Rgb24, byte>(destination);
+            PixelConverter.FromRgba32.ToRgb24(sourceBytes, destinationBytes);
         }        
     
         /// <inheritdoc />
         public override void ToArgb32(
             Configuration configuration,
-            ReadOnlySpan<Rgb24> sourcePixels,
-            Span<Argb32> destinationPixels)
+            ReadOnlySpan<Rgb24> source,
+            Span<Argb32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ReadOnlySpan<byte> source = MemoryMarshal.Cast<Rgb24, byte>(sourcePixels);
-            Span<byte> dest = MemoryMarshal.Cast<Argb32, byte>(destinationPixels);
-            PixelConverter.FromRgb24.ToArgb32(source, dest);
+            ReadOnlySpan<byte> sourceBytes = MemoryMarshal.Cast<Rgb24, byte>(source);
+            Span<byte> destinationBytes = MemoryMarshal.Cast<Argb32, byte>(destination);
+            PixelConverter.FromRgb24.ToArgb32(sourceBytes, destinationBytes);
         }
         
         /// <inheritdoc />
         public override void FromArgb32(
             Configuration configuration,
-            ReadOnlySpan<Argb32> sourcePixels,
-            Span<Rgb24> destinationPixels)
+            ReadOnlySpan<Argb32> source,
+            Span<Rgb24> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ReadOnlySpan<byte> source = MemoryMarshal.Cast<Argb32, byte>(sourcePixels);
-            Span<byte> dest = MemoryMarshal.Cast<Rgb24, byte>(destinationPixels);
-            PixelConverter.FromArgb32.ToRgb24(source, dest);
+            ReadOnlySpan<byte> sourceBytes = MemoryMarshal.Cast<Argb32, byte>(source);
+            Span<byte> destinationBytes = MemoryMarshal.Cast<Rgb24, byte>(destination);
+            PixelConverter.FromArgb32.ToRgb24(sourceBytes, destinationBytes);
         }        
     
         /// <inheritdoc />
         public override void ToAbgr32(
             Configuration configuration,
-            ReadOnlySpan<Rgb24> sourcePixels,
-            Span<Abgr32> destinationPixels)
+            ReadOnlySpan<Rgb24> source,
+            Span<Abgr32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ReadOnlySpan<byte> source = MemoryMarshal.Cast<Rgb24, byte>(sourcePixels);
-            Span<byte> dest = MemoryMarshal.Cast<Abgr32, byte>(destinationPixels);
-            PixelConverter.FromRgb24.ToAbgr32(source, dest);
+            ReadOnlySpan<byte> sourceBytes = MemoryMarshal.Cast<Rgb24, byte>(source);
+            Span<byte> destinationBytes = MemoryMarshal.Cast<Abgr32, byte>(destination);
+            PixelConverter.FromRgb24.ToAbgr32(sourceBytes, destinationBytes);
         }
         
         /// <inheritdoc />
         public override void FromAbgr32(
             Configuration configuration,
-            ReadOnlySpan<Abgr32> sourcePixels,
-            Span<Rgb24> destinationPixels)
+            ReadOnlySpan<Abgr32> source,
+            Span<Rgb24> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ReadOnlySpan<byte> source = MemoryMarshal.Cast<Abgr32, byte>(sourcePixels);
-            Span<byte> dest = MemoryMarshal.Cast<Rgb24, byte>(destinationPixels);
-            PixelConverter.FromAbgr32.ToRgb24(source, dest);
+            ReadOnlySpan<byte> sourceBytes = MemoryMarshal.Cast<Abgr32, byte>(source);
+            Span<byte> destinationBytes = MemoryMarshal.Cast<Rgb24, byte>(destination);
+            PixelConverter.FromAbgr32.ToRgb24(sourceBytes, destinationBytes);
         }        
     
         /// <inheritdoc />
         public override void ToBgra32(
             Configuration configuration,
-            ReadOnlySpan<Rgb24> sourcePixels,
-            Span<Bgra32> destinationPixels)
+            ReadOnlySpan<Rgb24> source,
+            Span<Bgra32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ReadOnlySpan<byte> source = MemoryMarshal.Cast<Rgb24, byte>(sourcePixels);
-            Span<byte> dest = MemoryMarshal.Cast<Bgra32, byte>(destinationPixels);
-            PixelConverter.FromRgb24.ToBgra32(source, dest);
+            ReadOnlySpan<byte> sourceBytes = MemoryMarshal.Cast<Rgb24, byte>(source);
+            Span<byte> destinationBytes = MemoryMarshal.Cast<Bgra32, byte>(destination);
+            PixelConverter.FromRgb24.ToBgra32(sourceBytes, destinationBytes);
         }
         
         /// <inheritdoc />
         public override void FromBgra32(
             Configuration configuration,
-            ReadOnlySpan<Bgra32> sourcePixels,
-            Span<Rgb24> destinationPixels)
+            ReadOnlySpan<Bgra32> source,
+            Span<Rgb24> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ReadOnlySpan<byte> source = MemoryMarshal.Cast<Bgra32, byte>(sourcePixels);
-            Span<byte> dest = MemoryMarshal.Cast<Rgb24, byte>(destinationPixels);
-            PixelConverter.FromBgra32.ToRgb24(source, dest);
+            ReadOnlySpan<byte> sourceBytes = MemoryMarshal.Cast<Bgra32, byte>(source);
+            Span<byte> destinationBytes = MemoryMarshal.Cast<Rgb24, byte>(destination);
+            PixelConverter.FromBgra32.ToRgb24(sourceBytes, destinationBytes);
         }        
     
         /// <inheritdoc />
         public override void ToBgr24(
             Configuration configuration,
-            ReadOnlySpan<Rgb24> sourcePixels,
-            Span<Bgr24> destinationPixels)
+            ReadOnlySpan<Rgb24> source,
+            Span<Bgr24> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ReadOnlySpan<byte> source = MemoryMarshal.Cast<Rgb24, byte>(sourcePixels);
-            Span<byte> dest = MemoryMarshal.Cast<Bgr24, byte>(destinationPixels);
-            PixelConverter.FromRgb24.ToBgr24(source, dest);
+            ReadOnlySpan<byte> sourceBytes = MemoryMarshal.Cast<Rgb24, byte>(source);
+            Span<byte> destinationBytes = MemoryMarshal.Cast<Bgr24, byte>(destination);
+            PixelConverter.FromRgb24.ToBgr24(sourceBytes, destinationBytes);
         }
         
         /// <inheritdoc />
         public override void FromBgr24(
             Configuration configuration,
-            ReadOnlySpan<Bgr24> sourcePixels,
-            Span<Rgb24> destinationPixels)
+            ReadOnlySpan<Bgr24> source,
+            Span<Rgb24> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ReadOnlySpan<byte> source = MemoryMarshal.Cast<Bgr24, byte>(sourcePixels);
-            Span<byte> dest = MemoryMarshal.Cast<Rgb24, byte>(destinationPixels);
-            PixelConverter.FromBgr24.ToRgb24(source, dest);
+            ReadOnlySpan<byte> sourceBytes = MemoryMarshal.Cast<Bgr24, byte>(source);
+            Span<byte> destinationBytes = MemoryMarshal.Cast<Rgb24, byte>(destination);
+            PixelConverter.FromBgr24.ToRgb24(sourceBytes, destinationBytes);
         }        
 
         /// <inheritdoc />
         public override void ToL8(
             Configuration configuration,
-            ReadOnlySpan<Rgb24> sourcePixels,
-            Span<L8> destinationPixels)
+            ReadOnlySpan<Rgb24> source,
+            Span<L8> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref Rgb24 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref L8 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref Rgb24 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref L8 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref Rgb24 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref L8 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromRgb24(sp);
+                Unsafe.Add(ref destinationBase, i) = L8.FromRgb24(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToL16(
             Configuration configuration,
-            ReadOnlySpan<Rgb24> sourcePixels,
-            Span<L16> destinationPixels)
+            ReadOnlySpan<Rgb24> source,
+            Span<L16> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref Rgb24 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref L16 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref Rgb24 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref L16 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref Rgb24 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref L16 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromRgb24(sp);
+                Unsafe.Add(ref destinationBase, i) = L16.FromRgb24(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToLa16(
             Configuration configuration,
-            ReadOnlySpan<Rgb24> sourcePixels,
-            Span<La16> destinationPixels)
+            ReadOnlySpan<Rgb24> source,
+            Span<La16> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref Rgb24 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref La16 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref Rgb24 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref La16 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref Rgb24 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref La16 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromRgb24(sp);
+                Unsafe.Add(ref destinationBase, i) = La16.FromRgb24(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToLa32(
             Configuration configuration,
-            ReadOnlySpan<Rgb24> sourcePixels,
-            Span<La32> destinationPixels)
+            ReadOnlySpan<Rgb24> source,
+            Span<La32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref Rgb24 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref La32 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref Rgb24 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref La32 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref Rgb24 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref La32 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromRgb24(sp);
+                Unsafe.Add(ref destinationBase, i) = La32.FromRgb24(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToRgb48(
             Configuration configuration,
-            ReadOnlySpan<Rgb24> sourcePixels,
-            Span<Rgb48> destinationPixels)
+            ReadOnlySpan<Rgb24> source,
+            Span<Rgb48> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref Rgb24 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref Rgb48 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref Rgb24 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref Rgb48 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref Rgb24 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref Rgb48 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromRgb24(sp);
+                Unsafe.Add(ref destinationBase, i) = Rgb48.FromRgb24(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToRgba64(
             Configuration configuration,
-            ReadOnlySpan<Rgb24> sourcePixels,
-            Span<Rgba64> destinationPixels)
+            ReadOnlySpan<Rgb24> source,
+            Span<Rgba64> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref Rgb24 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref Rgba64 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref Rgb24 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref Rgba64 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref Rgb24 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref Rgba64 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromRgb24(sp);
+                Unsafe.Add(ref destinationBase, i) = Rgba64.FromRgb24(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToBgra5551(
             Configuration configuration,
-            ReadOnlySpan<Rgb24> sourcePixels,
-            Span<Bgra5551> destinationPixels)
+            ReadOnlySpan<Rgb24> source,
+            Span<Bgra5551> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref Rgb24 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref Bgra5551 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref Rgb24 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref Bgra5551 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref Rgb24 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref Bgra5551 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromRgb24(sp);
+                Unsafe.Add(ref destinationBase, i) = Bgra5551.FromRgb24(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void From<TSourcePixel>(
             Configuration configuration,
-            ReadOnlySpan<TSourcePixel> sourcePixels,
-            Span<Rgb24> destinationPixels)
+            ReadOnlySpan<TSourcePixel> source,
+            Span<Rgb24> destination)
         {
-            PixelOperations<TSourcePixel>.Instance.ToRgb24(configuration, sourcePixels, destinationPixels.Slice(0, sourcePixels.Length));
+            PixelOperations<TSourcePixel>.Instance.ToRgb24(configuration, source, destination.Slice(0, source.Length));
         }
     }
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Generated/Rgb48.PixelOperations.Generated.cs b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Generated/Rgb48.PixelOperations.Generated.cs
index 60cfdad4b..69e06da21 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Generated/Rgb48.PixelOperations.Generated.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Generated/Rgb48.PixelOperations.Generated.cs
@@ -21,282 +21,246 @@ public partial struct Rgb48
     internal partial class PixelOperations : PixelOperations<Rgb48>
     {
         /// <inheritdoc />
-        public override void FromRgb48(Configuration configuration, ReadOnlySpan<Rgb48> source, Span<Rgb48> destinationPixels)
+        public override void FromRgb48(Configuration configuration, ReadOnlySpan<Rgb48> source, Span<Rgb48> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(source, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            source.CopyTo(destinationPixels.Slice(0, source.Length));
+            source.CopyTo(destination.Slice(0, source.Length));
         }
 
         /// <inheritdoc />
-        public override void ToRgb48(Configuration configuration, ReadOnlySpan<Rgb48> sourcePixels, Span<Rgb48> destinationPixels)
+        public override void ToRgb48(Configuration configuration, ReadOnlySpan<Rgb48> source, Span<Rgb48> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            sourcePixels.CopyTo(destinationPixels.Slice(0, sourcePixels.Length));
+            source.CopyTo(destination.Slice(0, source.Length));
         }
 
         /// <inheritdoc />
         public override void ToArgb32(
             Configuration configuration,
-            ReadOnlySpan<Rgb48> sourcePixels,
-            Span<Argb32> destinationPixels)
+            ReadOnlySpan<Rgb48> source,
+            Span<Argb32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref Rgb48 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref Argb32 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref Rgb48 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref Argb32 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref Rgb48 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref Argb32 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromRgb48(sp);
+                Unsafe.Add(ref destinationBase, i) = Argb32.FromRgb48(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToAbgr32(
             Configuration configuration,
-            ReadOnlySpan<Rgb48> sourcePixels,
-            Span<Abgr32> destinationPixels)
+            ReadOnlySpan<Rgb48> source,
+            Span<Abgr32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref Rgb48 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref Abgr32 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref Rgb48 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref Abgr32 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref Rgb48 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref Abgr32 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromRgb48(sp);
+                Unsafe.Add(ref destinationBase, i) = Abgr32.FromRgb48(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToBgr24(
             Configuration configuration,
-            ReadOnlySpan<Rgb48> sourcePixels,
-            Span<Bgr24> destinationPixels)
+            ReadOnlySpan<Rgb48> source,
+            Span<Bgr24> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref Rgb48 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref Bgr24 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref Rgb48 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref Bgr24 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref Rgb48 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref Bgr24 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromRgb48(sp);
+                Unsafe.Add(ref destinationBase, i) = Bgr24.FromRgb48(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToBgra32(
             Configuration configuration,
-            ReadOnlySpan<Rgb48> sourcePixels,
-            Span<Bgra32> destinationPixels)
+            ReadOnlySpan<Rgb48> source,
+            Span<Bgra32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref Rgb48 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref Bgra32 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref Rgb48 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref Bgra32 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref Rgb48 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref Bgra32 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromRgb48(sp);
+                Unsafe.Add(ref destinationBase, i) = Bgra32.FromRgb48(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToL8(
             Configuration configuration,
-            ReadOnlySpan<Rgb48> sourcePixels,
-            Span<L8> destinationPixels)
+            ReadOnlySpan<Rgb48> source,
+            Span<L8> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref Rgb48 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref L8 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref Rgb48 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref L8 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref Rgb48 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref L8 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromRgb48(sp);
+                Unsafe.Add(ref destinationBase, i) = L8.FromRgb48(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToL16(
             Configuration configuration,
-            ReadOnlySpan<Rgb48> sourcePixels,
-            Span<L16> destinationPixels)
+            ReadOnlySpan<Rgb48> source,
+            Span<L16> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref Rgb48 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref L16 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref Rgb48 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref L16 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref Rgb48 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref L16 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromRgb48(sp);
+                Unsafe.Add(ref destinationBase, i) = L16.FromRgb48(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToLa16(
             Configuration configuration,
-            ReadOnlySpan<Rgb48> sourcePixels,
-            Span<La16> destinationPixels)
+            ReadOnlySpan<Rgb48> source,
+            Span<La16> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref Rgb48 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref La16 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref Rgb48 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref La16 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref Rgb48 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref La16 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromRgb48(sp);
+                Unsafe.Add(ref destinationBase, i) = La16.FromRgb48(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToLa32(
             Configuration configuration,
-            ReadOnlySpan<Rgb48> sourcePixels,
-            Span<La32> destinationPixels)
+            ReadOnlySpan<Rgb48> source,
+            Span<La32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref Rgb48 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref La32 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref Rgb48 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref La32 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref Rgb48 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref La32 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromRgb48(sp);
+                Unsafe.Add(ref destinationBase, i) = La32.FromRgb48(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToRgb24(
             Configuration configuration,
-            ReadOnlySpan<Rgb48> sourcePixels,
-            Span<Rgb24> destinationPixels)
+            ReadOnlySpan<Rgb48> source,
+            Span<Rgb24> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref Rgb48 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref Rgb24 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref Rgb48 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref Rgb24 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref Rgb48 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref Rgb24 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromRgb48(sp);
+                Unsafe.Add(ref destinationBase, i) = Rgb24.FromRgb48(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToRgba32(
             Configuration configuration,
-            ReadOnlySpan<Rgb48> sourcePixels,
-            Span<Rgba32> destinationPixels)
+            ReadOnlySpan<Rgb48> source,
+            Span<Rgba32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref Rgb48 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref Rgba32 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref Rgb48 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref Rgba32 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref Rgb48 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref Rgba32 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromRgb48(sp);
+                Unsafe.Add(ref destinationBase, i) = Rgba32.FromRgb48(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToRgba64(
             Configuration configuration,
-            ReadOnlySpan<Rgb48> sourcePixels,
-            Span<Rgba64> destinationPixels)
+            ReadOnlySpan<Rgb48> source,
+            Span<Rgba64> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref Rgb48 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref Rgba64 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref Rgb48 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref Rgba64 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref Rgb48 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref Rgba64 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromRgb48(sp);
+                Unsafe.Add(ref destinationBase, i) = Rgba64.FromRgb48(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToBgra5551(
             Configuration configuration,
-            ReadOnlySpan<Rgb48> sourcePixels,
-            Span<Bgra5551> destinationPixels)
+            ReadOnlySpan<Rgb48> source,
+            Span<Bgra5551> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref Rgb48 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref Bgra5551 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref Rgb48 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref Bgra5551 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref Rgb48 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref Bgra5551 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromRgb48(sp);
+                Unsafe.Add(ref destinationBase, i) = Bgra5551.FromRgb48(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void From<TSourcePixel>(
             Configuration configuration,
-            ReadOnlySpan<TSourcePixel> sourcePixels,
-            Span<Rgb48> destinationPixels)
+            ReadOnlySpan<TSourcePixel> source,
+            Span<Rgb48> destination)
         {
-            PixelOperations<TSourcePixel>.Instance.ToRgb48(configuration, sourcePixels, destinationPixels.Slice(0, sourcePixels.Length));
+            PixelOperations<TSourcePixel>.Instance.ToRgb48(configuration, source, destination.Slice(0, source.Length));
         }
     }
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Generated/Rgba32.PixelOperations.Generated.cs b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Generated/Rgba32.PixelOperations.Generated.cs
index da7c9a6c9..8a98521f0 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Generated/Rgba32.PixelOperations.Generated.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Generated/Rgba32.PixelOperations.Generated.cs
@@ -21,317 +21,296 @@ public partial struct Rgba32
     internal partial class PixelOperations : PixelOperations<Rgba32>
     {
         /// <inheritdoc />
-        public override void FromRgba32(Configuration configuration, ReadOnlySpan<Rgba32> source, Span<Rgba32> destinationPixels)
+        public override void FromRgba32(Configuration configuration, ReadOnlySpan<Rgba32> source, Span<Rgba32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(source, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            source.CopyTo(destinationPixels.Slice(0, source.Length));
+            source.CopyTo(destination.Slice(0, source.Length));
         }
 
         /// <inheritdoc />
-        public override void ToRgba32(Configuration configuration, ReadOnlySpan<Rgba32> sourcePixels, Span<Rgba32> destinationPixels)
+        public override void ToRgba32(Configuration configuration, ReadOnlySpan<Rgba32> source, Span<Rgba32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            sourcePixels.CopyTo(destinationPixels.Slice(0, sourcePixels.Length));
+            source.CopyTo(destination.Slice(0, source.Length));
         }
     
         /// <inheritdoc />
         public override void ToArgb32(
             Configuration configuration,
-            ReadOnlySpan<Rgba32> sourcePixels,
-            Span<Argb32> destinationPixels)
+            ReadOnlySpan<Rgba32> source,
+            Span<Argb32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ReadOnlySpan<byte> source = MemoryMarshal.Cast<Rgba32, byte>(sourcePixels);
-            Span<byte> dest = MemoryMarshal.Cast<Argb32, byte>(destinationPixels);
-            PixelConverter.FromRgba32.ToArgb32(source, dest);
+            ReadOnlySpan<byte> sourceBytes = MemoryMarshal.Cast<Rgba32, byte>(source);
+            Span<byte> destinationBytes = MemoryMarshal.Cast<Argb32, byte>(destination);
+            PixelConverter.FromRgba32.ToArgb32(sourceBytes, destinationBytes);
         }
         
         /// <inheritdoc />
         public override void FromArgb32(
             Configuration configuration,
-            ReadOnlySpan<Argb32> sourcePixels,
-            Span<Rgba32> destinationPixels)
+            ReadOnlySpan<Argb32> source,
+            Span<Rgba32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ReadOnlySpan<byte> source = MemoryMarshal.Cast<Argb32, byte>(sourcePixels);
-            Span<byte> dest = MemoryMarshal.Cast<Rgba32, byte>(destinationPixels);
-            PixelConverter.FromArgb32.ToRgba32(source, dest);
+            ReadOnlySpan<byte> sourceBytes = MemoryMarshal.Cast<Argb32, byte>(source);
+            Span<byte> destinationBytes = MemoryMarshal.Cast<Rgba32, byte>(destination);
+            PixelConverter.FromArgb32.ToRgba32(sourceBytes, destinationBytes);
         }        
     
         /// <inheritdoc />
         public override void ToAbgr32(
             Configuration configuration,
-            ReadOnlySpan<Rgba32> sourcePixels,
-            Span<Abgr32> destinationPixels)
+            ReadOnlySpan<Rgba32> source,
+            Span<Abgr32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ReadOnlySpan<byte> source = MemoryMarshal.Cast<Rgba32, byte>(sourcePixels);
-            Span<byte> dest = MemoryMarshal.Cast<Abgr32, byte>(destinationPixels);
-            PixelConverter.FromRgba32.ToAbgr32(source, dest);
+            ReadOnlySpan<byte> sourceBytes = MemoryMarshal.Cast<Rgba32, byte>(source);
+            Span<byte> destinationBytes = MemoryMarshal.Cast<Abgr32, byte>(destination);
+            PixelConverter.FromRgba32.ToAbgr32(sourceBytes, destinationBytes);
         }
         
         /// <inheritdoc />
         public override void FromAbgr32(
             Configuration configuration,
-            ReadOnlySpan<Abgr32> sourcePixels,
-            Span<Rgba32> destinationPixels)
+            ReadOnlySpan<Abgr32> source,
+            Span<Rgba32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ReadOnlySpan<byte> source = MemoryMarshal.Cast<Abgr32, byte>(sourcePixels);
-            Span<byte> dest = MemoryMarshal.Cast<Rgba32, byte>(destinationPixels);
-            PixelConverter.FromAbgr32.ToRgba32(source, dest);
+            ReadOnlySpan<byte> sourceBytes = MemoryMarshal.Cast<Abgr32, byte>(source);
+            Span<byte> destinationBytes = MemoryMarshal.Cast<Rgba32, byte>(destination);
+            PixelConverter.FromAbgr32.ToRgba32(sourceBytes, destinationBytes);
         }        
     
         /// <inheritdoc />
         public override void ToBgra32(
             Configuration configuration,
-            ReadOnlySpan<Rgba32> sourcePixels,
-            Span<Bgra32> destinationPixels)
+            ReadOnlySpan<Rgba32> source,
+            Span<Bgra32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ReadOnlySpan<byte> source = MemoryMarshal.Cast<Rgba32, byte>(sourcePixels);
-            Span<byte> dest = MemoryMarshal.Cast<Bgra32, byte>(destinationPixels);
-            PixelConverter.FromRgba32.ToBgra32(source, dest);
+            ReadOnlySpan<byte> sourceBytes = MemoryMarshal.Cast<Rgba32, byte>(source);
+            Span<byte> destinationBytes = MemoryMarshal.Cast<Bgra32, byte>(destination);
+            PixelConverter.FromRgba32.ToBgra32(sourceBytes, destinationBytes);
         }
         
         /// <inheritdoc />
         public override void FromBgra32(
             Configuration configuration,
-            ReadOnlySpan<Bgra32> sourcePixels,
-            Span<Rgba32> destinationPixels)
+            ReadOnlySpan<Bgra32> source,
+            Span<Rgba32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ReadOnlySpan<byte> source = MemoryMarshal.Cast<Bgra32, byte>(sourcePixels);
-            Span<byte> dest = MemoryMarshal.Cast<Rgba32, byte>(destinationPixels);
-            PixelConverter.FromBgra32.ToRgba32(source, dest);
+            ReadOnlySpan<byte> sourceBytes = MemoryMarshal.Cast<Bgra32, byte>(source);
+            Span<byte> destinationBytes = MemoryMarshal.Cast<Rgba32, byte>(destination);
+            PixelConverter.FromBgra32.ToRgba32(sourceBytes, destinationBytes);
         }        
     
         /// <inheritdoc />
         public override void ToRgb24(
             Configuration configuration,
-            ReadOnlySpan<Rgba32> sourcePixels,
-            Span<Rgb24> destinationPixels)
+            ReadOnlySpan<Rgba32> source,
+            Span<Rgb24> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ReadOnlySpan<byte> source = MemoryMarshal.Cast<Rgba32, byte>(sourcePixels);
-            Span<byte> dest = MemoryMarshal.Cast<Rgb24, byte>(destinationPixels);
-            PixelConverter.FromRgba32.ToRgb24(source, dest);
+            ReadOnlySpan<byte> sourceBytes = MemoryMarshal.Cast<Rgba32, byte>(source);
+            Span<byte> destinationBytes = MemoryMarshal.Cast<Rgb24, byte>(destination);
+            PixelConverter.FromRgba32.ToRgb24(sourceBytes, destinationBytes);
         }
         
         /// <inheritdoc />
         public override void FromRgb24(
             Configuration configuration,
-            ReadOnlySpan<Rgb24> sourcePixels,
-            Span<Rgba32> destinationPixels)
+            ReadOnlySpan<Rgb24> source,
+            Span<Rgba32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ReadOnlySpan<byte> source = MemoryMarshal.Cast<Rgb24, byte>(sourcePixels);
-            Span<byte> dest = MemoryMarshal.Cast<Rgba32, byte>(destinationPixels);
-            PixelConverter.FromRgb24.ToRgba32(source, dest);
+            ReadOnlySpan<byte> sourceBytes = MemoryMarshal.Cast<Rgb24, byte>(source);
+            Span<byte> destinationBytes = MemoryMarshal.Cast<Rgba32, byte>(destination);
+            PixelConverter.FromRgb24.ToRgba32(sourceBytes, destinationBytes);
         }        
     
         /// <inheritdoc />
         public override void ToBgr24(
             Configuration configuration,
-            ReadOnlySpan<Rgba32> sourcePixels,
-            Span<Bgr24> destinationPixels)
+            ReadOnlySpan<Rgba32> source,
+            Span<Bgr24> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ReadOnlySpan<byte> source = MemoryMarshal.Cast<Rgba32, byte>(sourcePixels);
-            Span<byte> dest = MemoryMarshal.Cast<Bgr24, byte>(destinationPixels);
-            PixelConverter.FromRgba32.ToBgr24(source, dest);
+            ReadOnlySpan<byte> sourceBytes = MemoryMarshal.Cast<Rgba32, byte>(source);
+            Span<byte> destinationBytes = MemoryMarshal.Cast<Bgr24, byte>(destination);
+            PixelConverter.FromRgba32.ToBgr24(sourceBytes, destinationBytes);
         }
         
         /// <inheritdoc />
         public override void FromBgr24(
             Configuration configuration,
-            ReadOnlySpan<Bgr24> sourcePixels,
-            Span<Rgba32> destinationPixels)
+            ReadOnlySpan<Bgr24> source,
+            Span<Rgba32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ReadOnlySpan<byte> source = MemoryMarshal.Cast<Bgr24, byte>(sourcePixels);
-            Span<byte> dest = MemoryMarshal.Cast<Rgba32, byte>(destinationPixels);
-            PixelConverter.FromBgr24.ToRgba32(source, dest);
+            ReadOnlySpan<byte> sourceBytes = MemoryMarshal.Cast<Bgr24, byte>(source);
+            Span<byte> destinationBytes = MemoryMarshal.Cast<Rgba32, byte>(destination);
+            PixelConverter.FromBgr24.ToRgba32(sourceBytes, destinationBytes);
         }        
 
         /// <inheritdoc />
         public override void ToL8(
             Configuration configuration,
-            ReadOnlySpan<Rgba32> sourcePixels,
-            Span<L8> destinationPixels)
+            ReadOnlySpan<Rgba32> source,
+            Span<L8> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref Rgba32 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref L8 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref Rgba32 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref L8 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref Rgba32 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref L8 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromRgba32(sp);
+                Unsafe.Add(ref destinationBase, i) = L8.FromRgba32(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToL16(
             Configuration configuration,
-            ReadOnlySpan<Rgba32> sourcePixels,
-            Span<L16> destinationPixels)
+            ReadOnlySpan<Rgba32> source,
+            Span<L16> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref Rgba32 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref L16 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref Rgba32 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref L16 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref Rgba32 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref L16 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromRgba32(sp);
+                Unsafe.Add(ref destinationBase, i) = L16.FromRgba32(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToLa16(
             Configuration configuration,
-            ReadOnlySpan<Rgba32> sourcePixels,
-            Span<La16> destinationPixels)
+            ReadOnlySpan<Rgba32> source,
+            Span<La16> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref Rgba32 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref La16 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref Rgba32 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref La16 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref Rgba32 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref La16 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromRgba32(sp);
+                Unsafe.Add(ref destinationBase, i) = La16.FromRgba32(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToLa32(
             Configuration configuration,
-            ReadOnlySpan<Rgba32> sourcePixels,
-            Span<La32> destinationPixels)
+            ReadOnlySpan<Rgba32> source,
+            Span<La32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref Rgba32 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref La32 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref Rgba32 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref La32 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref Rgba32 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref La32 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromRgba32(sp);
+                Unsafe.Add(ref destinationBase, i) = La32.FromRgba32(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToRgb48(
             Configuration configuration,
-            ReadOnlySpan<Rgba32> sourcePixels,
-            Span<Rgb48> destinationPixels)
+            ReadOnlySpan<Rgba32> source,
+            Span<Rgb48> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref Rgba32 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref Rgb48 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref Rgba32 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref Rgb48 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref Rgba32 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref Rgb48 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromRgba32(sp);
+                Unsafe.Add(ref destinationBase, i) = Rgb48.FromRgba32(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToRgba64(
             Configuration configuration,
-            ReadOnlySpan<Rgba32> sourcePixels,
-            Span<Rgba64> destinationPixels)
+            ReadOnlySpan<Rgba32> source,
+            Span<Rgba64> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref Rgba32 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref Rgba64 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref Rgba32 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref Rgba64 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref Rgba32 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref Rgba64 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromRgba32(sp);
+                Unsafe.Add(ref destinationBase, i) = Rgba64.FromRgba32(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToBgra5551(
             Configuration configuration,
-            ReadOnlySpan<Rgba32> sourcePixels,
-            Span<Bgra5551> destinationPixels)
+            ReadOnlySpan<Rgba32> source,
+            Span<Bgra5551> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref Rgba32 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref Bgra5551 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref Rgba32 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref Bgra5551 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref Rgba32 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref Bgra5551 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromRgba32(sp);
+                Unsafe.Add(ref destinationBase, i) = Bgra5551.FromRgba32(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void From<TSourcePixel>(
             Configuration configuration,
-            ReadOnlySpan<TSourcePixel> sourcePixels,
-            Span<Rgba32> destinationPixels)
+            ReadOnlySpan<TSourcePixel> source,
+            Span<Rgba32> destination)
         {
-            PixelOperations<TSourcePixel>.Instance.ToRgba32(configuration, sourcePixels, destinationPixels.Slice(0, sourcePixels.Length));
+            PixelOperations<TSourcePixel>.Instance.ToRgba32(configuration, source, destination.Slice(0, source.Length));
         }
     }
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Generated/Rgba64.PixelOperations.Generated.cs b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Generated/Rgba64.PixelOperations.Generated.cs
index b6236f8a6..4679e950e 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Generated/Rgba64.PixelOperations.Generated.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Generated/Rgba64.PixelOperations.Generated.cs
@@ -21,282 +21,246 @@ public partial struct Rgba64
     internal partial class PixelOperations : PixelOperations<Rgba64>
     {
         /// <inheritdoc />
-        public override void FromRgba64(Configuration configuration, ReadOnlySpan<Rgba64> source, Span<Rgba64> destinationPixels)
+        public override void FromRgba64(Configuration configuration, ReadOnlySpan<Rgba64> source, Span<Rgba64> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(source, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            source.CopyTo(destinationPixels.Slice(0, source.Length));
+            source.CopyTo(destination.Slice(0, source.Length));
         }
 
         /// <inheritdoc />
-        public override void ToRgba64(Configuration configuration, ReadOnlySpan<Rgba64> sourcePixels, Span<Rgba64> destinationPixels)
+        public override void ToRgba64(Configuration configuration, ReadOnlySpan<Rgba64> source, Span<Rgba64> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            sourcePixels.CopyTo(destinationPixels.Slice(0, sourcePixels.Length));
+            source.CopyTo(destination.Slice(0, source.Length));
         }
 
         /// <inheritdoc />
         public override void ToArgb32(
             Configuration configuration,
-            ReadOnlySpan<Rgba64> sourcePixels,
-            Span<Argb32> destinationPixels)
+            ReadOnlySpan<Rgba64> source,
+            Span<Argb32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref Rgba64 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref Argb32 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref Rgba64 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref Argb32 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref Rgba64 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref Argb32 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromRgba64(sp);
+                Unsafe.Add(ref destinationBase, i) = Argb32.FromRgba64(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToAbgr32(
             Configuration configuration,
-            ReadOnlySpan<Rgba64> sourcePixels,
-            Span<Abgr32> destinationPixels)
+            ReadOnlySpan<Rgba64> source,
+            Span<Abgr32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref Rgba64 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref Abgr32 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref Rgba64 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref Abgr32 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref Rgba64 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref Abgr32 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromRgba64(sp);
+                Unsafe.Add(ref destinationBase, i) = Abgr32.FromRgba64(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToBgr24(
             Configuration configuration,
-            ReadOnlySpan<Rgba64> sourcePixels,
-            Span<Bgr24> destinationPixels)
+            ReadOnlySpan<Rgba64> source,
+            Span<Bgr24> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref Rgba64 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref Bgr24 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref Rgba64 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref Bgr24 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref Rgba64 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref Bgr24 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromRgba64(sp);
+                Unsafe.Add(ref destinationBase, i) = Bgr24.FromRgba64(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToBgra32(
             Configuration configuration,
-            ReadOnlySpan<Rgba64> sourcePixels,
-            Span<Bgra32> destinationPixels)
+            ReadOnlySpan<Rgba64> source,
+            Span<Bgra32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref Rgba64 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref Bgra32 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref Rgba64 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref Bgra32 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref Rgba64 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref Bgra32 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromRgba64(sp);
+                Unsafe.Add(ref destinationBase, i) = Bgra32.FromRgba64(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToL8(
             Configuration configuration,
-            ReadOnlySpan<Rgba64> sourcePixels,
-            Span<L8> destinationPixels)
+            ReadOnlySpan<Rgba64> source,
+            Span<L8> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref Rgba64 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref L8 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref Rgba64 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref L8 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref Rgba64 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref L8 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromRgba64(sp);
+                Unsafe.Add(ref destinationBase, i) = L8.FromRgba64(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToL16(
             Configuration configuration,
-            ReadOnlySpan<Rgba64> sourcePixels,
-            Span<L16> destinationPixels)
+            ReadOnlySpan<Rgba64> source,
+            Span<L16> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref Rgba64 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref L16 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref Rgba64 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref L16 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref Rgba64 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref L16 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromRgba64(sp);
+                Unsafe.Add(ref destinationBase, i) = L16.FromRgba64(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToLa16(
             Configuration configuration,
-            ReadOnlySpan<Rgba64> sourcePixels,
-            Span<La16> destinationPixels)
+            ReadOnlySpan<Rgba64> source,
+            Span<La16> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref Rgba64 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref La16 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref Rgba64 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref La16 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref Rgba64 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref La16 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromRgba64(sp);
+                Unsafe.Add(ref destinationBase, i) = La16.FromRgba64(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToLa32(
             Configuration configuration,
-            ReadOnlySpan<Rgba64> sourcePixels,
-            Span<La32> destinationPixels)
+            ReadOnlySpan<Rgba64> source,
+            Span<La32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref Rgba64 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref La32 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref Rgba64 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref La32 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref Rgba64 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref La32 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromRgba64(sp);
+                Unsafe.Add(ref destinationBase, i) = La32.FromRgba64(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToRgb24(
             Configuration configuration,
-            ReadOnlySpan<Rgba64> sourcePixels,
-            Span<Rgb24> destinationPixels)
+            ReadOnlySpan<Rgba64> source,
+            Span<Rgb24> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref Rgba64 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref Rgb24 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref Rgba64 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref Rgb24 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref Rgba64 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref Rgb24 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromRgba64(sp);
+                Unsafe.Add(ref destinationBase, i) = Rgb24.FromRgba64(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToRgba32(
             Configuration configuration,
-            ReadOnlySpan<Rgba64> sourcePixels,
-            Span<Rgba32> destinationPixels)
+            ReadOnlySpan<Rgba64> source,
+            Span<Rgba32> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref Rgba64 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref Rgba32 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref Rgba64 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref Rgba32 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref Rgba64 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref Rgba32 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromRgba64(sp);
+                Unsafe.Add(ref destinationBase, i) = Rgba32.FromRgba64(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToRgb48(
             Configuration configuration,
-            ReadOnlySpan<Rgba64> sourcePixels,
-            Span<Rgb48> destinationPixels)
+            ReadOnlySpan<Rgba64> source,
+            Span<Rgb48> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref Rgba64 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref Rgb48 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref Rgba64 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref Rgb48 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref Rgba64 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref Rgb48 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromRgba64(sp);
+                Unsafe.Add(ref destinationBase, i) = Rgb48.FromRgba64(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void ToBgra5551(
             Configuration configuration,
-            ReadOnlySpan<Rgba64> sourcePixels,
-            Span<Bgra5551> destinationPixels)
+            ReadOnlySpan<Rgba64> source,
+            Span<Bgra5551> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref Rgba64 sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref Bgra5551 destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref Rgba64 sourceBase = ref MemoryMarshal.GetReference(source);
+            ref Bgra5551 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref Rgba64 sp = ref Unsafe.Add(ref sourceRef, i);
-                ref Bgra5551 dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.FromRgba64(sp);
+                Unsafe.Add(ref destinationBase, i) = Bgra5551.FromRgba64(Unsafe.Add(ref sourceBase, i));
             }
         }
 
         /// <inheritdoc />
         public override void From<TSourcePixel>(
             Configuration configuration,
-            ReadOnlySpan<TSourcePixel> sourcePixels,
-            Span<Rgba64> destinationPixels)
+            ReadOnlySpan<TSourcePixel> source,
+            Span<Rgba64> destination)
         {
-            PixelOperations<TSourcePixel>.Instance.ToRgba64(configuration, sourcePixels, destinationPixels.Slice(0, sourcePixels.Length));
+            PixelOperations<TSourcePixel>.Instance.ToRgba64(configuration, source, destination.Slice(0, source.Length));
         }
     }
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Generated/_Common.ttinclude b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Generated/_Common.ttinclude
index f7e178d7f..c4d5a6b95 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Generated/_Common.ttinclude
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Generated/_Common.ttinclude
@@ -57,10 +57,10 @@ using SixLabors.ImageSharp.PixelFormats.Utils;
         /// <inheritdoc />
         public override void From<TSourcePixel>(
             Configuration configuration,
-            ReadOnlySpan<TSourcePixel> sourcePixels,
-            Span<<#=pixelType#>> destinationPixels)
+            ReadOnlySpan<TSourcePixel> source,
+            Span<<#=pixelType#>> destination)
         {
-            PixelOperations<TSourcePixel>.Instance.To<#=pixelType#>(configuration, sourcePixels, destinationPixels.Slice(0, sourcePixels.Length));
+            PixelOperations<TSourcePixel>.Instance.To<#=pixelType#>(configuration, source, destination.Slice(0, source.Length));
         }
 <#+
     }
@@ -68,21 +68,21 @@ using SixLabors.ImageSharp.PixelFormats.Utils;
     void GenerateDefaultSelfConversionMethods(string pixelType)
     {
 #>/// <inheritdoc />
-        public override void From<#=pixelType#>(Configuration configuration, ReadOnlySpan<<#=pixelType#>> source, Span<<#=pixelType#>> destinationPixels)
+        public override void From<#=pixelType#>(Configuration configuration, ReadOnlySpan<<#=pixelType#>> source, Span<<#=pixelType#>> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(source, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            source.CopyTo(destinationPixels.Slice(0, source.Length));
+            source.CopyTo(destination.Slice(0, source.Length));
         }
 
         /// <inheritdoc />
-        public override void To<#=pixelType#>(Configuration configuration, ReadOnlySpan<<#=pixelType#>> sourcePixels, Span<<#=pixelType#>> destinationPixels)
+        public override void To<#=pixelType#>(Configuration configuration, ReadOnlySpan<<#=pixelType#>> source, Span<<#=pixelType#>> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            sourcePixels.CopyTo(destinationPixels.Slice(0, sourcePixels.Length));
+            source.CopyTo(destination.Slice(0, source.Length));
         }
 <#+
     }
@@ -94,21 +94,18 @@ using SixLabors.ImageSharp.PixelFormats.Utils;
         /// <inheritdoc />
         public override void To<#=toPixelType#>(
             Configuration configuration,
-            ReadOnlySpan<<#=fromPixelType#>> sourcePixels,
-            Span<<#=toPixelType#>> destinationPixels)
+            ReadOnlySpan<<#=fromPixelType#>> source,
+            Span<<#=toPixelType#>> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ref <#=fromPixelType#> sourceRef = ref MemoryMarshal.GetReference(sourcePixels);
-            ref <#=toPixelType#> destRef = ref MemoryMarshal.GetReference(destinationPixels);
+            ref <#=fromPixelType#> sourceBase = ref MemoryMarshal.GetReference(source);
+            ref <#=toPixelType#> destinationBase = ref MemoryMarshal.GetReference(destination);
 
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+            for (nuint i = 0; i < (uint)source.Length; i++)
             {
-                ref <#=fromPixelType#> sp = ref Unsafe.Add(ref sourceRef, i);
-                ref <#=toPixelType#> dp = ref Unsafe.Add(ref destRef, i);
-
-                dp.From<#=fromPixelType#>(sp);
+                Unsafe.Add(ref destinationBase, i) = <#=toPixelType#>.From<#=fromPixelType#>(Unsafe.Add(ref sourceBase, i));
             }
         }
 <#+
@@ -121,29 +118,29 @@ using SixLabors.ImageSharp.PixelFormats.Utils;
         /// <inheritdoc />
         public override void To<#=otherPixelType#>(
             Configuration configuration,
-            ReadOnlySpan<<#=thisPixelType#>> sourcePixels,
-            Span<<#=otherPixelType#>> destinationPixels)
+            ReadOnlySpan<<#=thisPixelType#>> source,
+            Span<<#=otherPixelType#>> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ReadOnlySpan<byte> source = MemoryMarshal.Cast<<#=thisPixelType#>, byte>(sourcePixels);
-            Span<byte> dest = MemoryMarshal.Cast<<#=otherPixelType#>, byte>(destinationPixels);
-            PixelConverter.From<#=thisPixelType#>.To<#=otherPixelType#>(source, dest);
+            ReadOnlySpan<byte> sourceBytes = MemoryMarshal.Cast<<#=thisPixelType#>, byte>(source);
+            Span<byte> destinationBytes = MemoryMarshal.Cast<<#=otherPixelType#>, byte>(destination);
+            PixelConverter.From<#=thisPixelType#>.To<#=otherPixelType#>(sourceBytes, destinationBytes);
         }
         
         /// <inheritdoc />
         public override void From<#=otherPixelType#>(
             Configuration configuration,
-            ReadOnlySpan<<#=otherPixelType#>> sourcePixels,
-            Span<<#=thisPixelType#>> destinationPixels)
+            ReadOnlySpan<<#=otherPixelType#>> source,
+            Span<<#=thisPixelType#>> destination)
         {
             Guard.NotNull(configuration, nameof(configuration));
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            ReadOnlySpan<byte> source = MemoryMarshal.Cast<<#=otherPixelType#>, byte>(sourcePixels);
-            Span<byte> dest = MemoryMarshal.Cast<<#=thisPixelType#>, byte>(destinationPixels);
-            PixelConverter.From<#=otherPixelType#>.To<#=thisPixelType#>(source, dest);
+            ReadOnlySpan<byte> sourceBytes = MemoryMarshal.Cast<<#=otherPixelType#>, byte>(source);
+            Span<byte> destinationBytes = MemoryMarshal.Cast<<#=thisPixelType#>, byte>(destination);
+            PixelConverter.From<#=otherPixelType#>.To<#=thisPixelType#>(sourceBytes, destinationBytes);
         }        
 <#+
     }
@@ -161,20 +158,20 @@ using SixLabors.ImageSharp.PixelFormats.Utils;
         public override void FromVector4Destructive(
             Configuration configuration,
             Span<Vector4> sourceVectors,
-            Span<<#=pixelType#>> destinationPixels,
+            Span<<#=pixelType#>> destination,
             PixelConversionModifiers modifiers)
         {
-            Vector4Converters.RgbaCompatible.FromVector4(configuration, this, sourceVectors, destinationPixels, modifiers.Remove(<#=removeTheseModifiers#>));
+            Vector4Converters.RgbaCompatible.FromVector4(configuration, this, sourceVectors, destination, modifiers.Remove(<#=removeTheseModifiers#>));
         }
 
         /// <inheritdoc />
         public override void ToVector4(
             Configuration configuration,
-            ReadOnlySpan<<#=pixelType#>> sourcePixels,
-            Span<Vector4> destVectors,
+            ReadOnlySpan<<#=pixelType#>> source,
+            Span<Vector4> destination,
             PixelConversionModifiers modifiers)
         {
-            Vector4Converters.RgbaCompatible.ToVector4(configuration, this, sourcePixels, destVectors, modifiers.Remove(<#=removeTheseModifiers#>));
+            Vector4Converters.RgbaCompatible.ToVector4(configuration, this, source, destination, modifiers.Remove(<#=removeTheseModifiers#>));
         }
 <#+
     }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/HalfSingle.PixelOperations.cs b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/HalfSingle.PixelOperations.cs
index c8c4110c7..770f3a1de 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/HalfSingle.PixelOperations.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/HalfSingle.PixelOperations.cs
@@ -1,8 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using SixLabors.ImageSharp.Formats;
-
 namespace SixLabors.ImageSharp.PixelFormats;
 
 /// <content>
@@ -13,12 +11,5 @@ public partial struct HalfSingle
     /// <summary>
     /// Provides optimized overrides for bulk operations.
     /// </summary>
-    internal class PixelOperations : PixelOperations<HalfSingle>
-    {
-        private static readonly Lazy<PixelTypeInfo> LazyInfo =
-            new Lazy<PixelTypeInfo>(() => PixelTypeInfo.Create<HalfSingle>(PixelAlphaRepresentation.None), true);
-
-        /// <inheritdoc />
-        public override PixelTypeInfo GetPixelTypeInfo() => LazyInfo.Value;
-    }
+    internal class PixelOperations : PixelOperations<HalfSingle>;
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/HalfVector2.PixelOperations.cs b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/HalfVector2.PixelOperations.cs
index bdf58145f..160ab9bd0 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/HalfVector2.PixelOperations.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/HalfVector2.PixelOperations.cs
@@ -1,8 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using SixLabors.ImageSharp.Formats;
-
 namespace SixLabors.ImageSharp.PixelFormats;
 
 /// <content>
@@ -13,12 +11,5 @@ public partial struct HalfVector2
     /// <summary>
     /// Provides optimized overrides for bulk operations.
     /// </summary>
-    internal class PixelOperations : PixelOperations<HalfVector2>
-    {
-        private static readonly Lazy<PixelTypeInfo> LazyInfo =
-            new Lazy<PixelTypeInfo>(() => PixelTypeInfo.Create<HalfVector2>(PixelAlphaRepresentation.None), true);
-
-        /// <inheritdoc />
-        public override PixelTypeInfo GetPixelTypeInfo() => LazyInfo.Value;
-    }
+    internal class PixelOperations : PixelOperations<HalfVector2>;
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/HalfVector4.PixelOperations.cs b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/HalfVector4.PixelOperations.cs
index c3fe59804..703138454 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/HalfVector4.PixelOperations.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/HalfVector4.PixelOperations.cs
@@ -1,8 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using SixLabors.ImageSharp.Formats;
-
 namespace SixLabors.ImageSharp.PixelFormats;
 
 /// <content>
@@ -13,12 +11,5 @@ public partial struct HalfVector4
     /// <summary>
     /// Provides optimized overrides for bulk operations.
     /// </summary>
-    internal class PixelOperations : PixelOperations<HalfVector4>
-    {
-        private static readonly Lazy<PixelTypeInfo> LazyInfo =
-            new Lazy<PixelTypeInfo>(() => PixelTypeInfo.Create<HalfVector4>(PixelAlphaRepresentation.Unassociated), true);
-
-        /// <inheritdoc />
-        public override PixelTypeInfo GetPixelTypeInfo() => LazyInfo.Value;
-    }
+    internal class PixelOperations : PixelOperations<HalfVector4>;
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/L16.PixelOperations.cs b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/L16.PixelOperations.cs
index 7495cee53..c9714c217 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/L16.PixelOperations.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/L16.PixelOperations.cs
@@ -1,8 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using SixLabors.ImageSharp.Formats;
-
 namespace SixLabors.ImageSharp.PixelFormats;
 
 /// <content>
@@ -13,12 +11,5 @@ public partial struct L16
     /// <summary>
     /// Provides optimized overrides for bulk operations.
     /// </summary>
-    internal partial class PixelOperations : PixelOperations<L16>
-    {
-        private static readonly Lazy<PixelTypeInfo> LazyInfo =
-            new Lazy<PixelTypeInfo>(() => PixelTypeInfo.Create<L16>(PixelAlphaRepresentation.None), true);
-
-        /// <inheritdoc />
-        public override PixelTypeInfo GetPixelTypeInfo() => LazyInfo.Value;
-    }
+    internal partial class PixelOperations : PixelOperations<L16>;
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/L8.PixelOperations.cs b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/L8.PixelOperations.cs
index 5dd98c3a6..e7b463fe0 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/L8.PixelOperations.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/L8.PixelOperations.cs
@@ -1,8 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using SixLabors.ImageSharp.Formats;
-
 namespace SixLabors.ImageSharp.PixelFormats;
 
 /// <content>
@@ -13,12 +11,5 @@ public partial struct L8
     /// <summary>
     /// Provides optimized overrides for bulk operations.
     /// </summary>
-    internal partial class PixelOperations : PixelOperations<L8>
-    {
-        private static readonly Lazy<PixelTypeInfo> LazyInfo =
-            new Lazy<PixelTypeInfo>(() => PixelTypeInfo.Create<L8>(PixelAlphaRepresentation.None), true);
-
-        /// <inheritdoc />
-        public override PixelTypeInfo GetPixelTypeInfo() => LazyInfo.Value;
-    }
+    internal partial class PixelOperations : PixelOperations<L8>;
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/La16.PixelOperations.cs b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/La16.PixelOperations.cs
index d9bda3e0f..316c96565 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/La16.PixelOperations.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/La16.PixelOperations.cs
@@ -1,8 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using SixLabors.ImageSharp.Formats;
-
 namespace SixLabors.ImageSharp.PixelFormats;
 
 /// <content>
@@ -13,12 +11,5 @@ public partial struct La16
     /// <summary>
     /// Provides optimized overrides for bulk operations.
     /// </summary>
-    internal partial class PixelOperations : PixelOperations<La16>
-    {
-        private static readonly Lazy<PixelTypeInfo> LazyInfo =
-            new Lazy<PixelTypeInfo>(() => PixelTypeInfo.Create<La16>(PixelAlphaRepresentation.Unassociated), true);
-
-        /// <inheritdoc />
-        public override PixelTypeInfo GetPixelTypeInfo() => LazyInfo.Value;
-    }
+    internal partial class PixelOperations : PixelOperations<La16>;
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/La32.PixelOperations.cs b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/La32.PixelOperations.cs
index 1fb5adfc8..34a865533 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/La32.PixelOperations.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/La32.PixelOperations.cs
@@ -1,8 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using SixLabors.ImageSharp.Formats;
-
 namespace SixLabors.ImageSharp.PixelFormats;
 
 /// <content>
@@ -13,12 +11,5 @@ public partial struct La32
     /// <summary>
     /// Provides optimized overrides for bulk operations.
     /// </summary>
-    internal partial class PixelOperations : PixelOperations<La32>
-    {
-        private static readonly Lazy<PixelTypeInfo> LazyInfo =
-            new Lazy<PixelTypeInfo>(() => PixelTypeInfo.Create<La32>(PixelAlphaRepresentation.Unassociated), true);
-
-        /// <inheritdoc />
-        public override PixelTypeInfo GetPixelTypeInfo() => LazyInfo.Value;
-    }
+    internal partial class PixelOperations : PixelOperations<La32>;
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/NormalizedByte2.PixelOperations.cs b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/NormalizedByte2.PixelOperations.cs
index 717629586..36f4a0bf5 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/NormalizedByte2.PixelOperations.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/NormalizedByte2.PixelOperations.cs
@@ -1,8 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using SixLabors.ImageSharp.Formats;
-
 namespace SixLabors.ImageSharp.PixelFormats;
 
 /// <content>
@@ -13,12 +11,5 @@ public partial struct NormalizedByte2
     /// <summary>
     /// Provides optimized overrides for bulk operations.
     /// </summary>
-    internal class PixelOperations : PixelOperations<NormalizedByte2>
-    {
-        private static readonly Lazy<PixelTypeInfo> LazyInfo =
-            new Lazy<PixelTypeInfo>(() => PixelTypeInfo.Create<NormalizedByte2>(PixelAlphaRepresentation.None), true);
-
-        /// <inheritdoc />
-        public override PixelTypeInfo GetPixelTypeInfo() => LazyInfo.Value;
-    }
+    internal class PixelOperations : PixelOperations<NormalizedByte2>;
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/NormalizedByte4.PixelOperations.cs b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/NormalizedByte4.PixelOperations.cs
index 9bb48f592..e67321e4f 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/NormalizedByte4.PixelOperations.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/NormalizedByte4.PixelOperations.cs
@@ -1,8 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using SixLabors.ImageSharp.Formats;
-
 namespace SixLabors.ImageSharp.PixelFormats;
 
 /// <content>
@@ -13,12 +11,5 @@ public partial struct NormalizedByte4
     /// <summary>
     /// Provides optimized overrides for bulk operations.
     /// </summary>
-    internal class PixelOperations : PixelOperations<NormalizedByte4>
-    {
-        private static readonly Lazy<PixelTypeInfo> LazyInfo =
-            new Lazy<PixelTypeInfo>(() => PixelTypeInfo.Create<NormalizedByte4>(PixelAlphaRepresentation.Unassociated), true);
-
-        /// <inheritdoc />
-        public override PixelTypeInfo GetPixelTypeInfo() => LazyInfo.Value;
-    }
+    internal class PixelOperations : PixelOperations<NormalizedByte4>;
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/NormalizedShort2.PixelOperations.cs b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/NormalizedShort2.PixelOperations.cs
index 3913f64bb..99636cb37 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/NormalizedShort2.PixelOperations.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/NormalizedShort2.PixelOperations.cs
@@ -1,8 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using SixLabors.ImageSharp.Formats;
-
 namespace SixLabors.ImageSharp.PixelFormats;
 
 /// <content>
@@ -13,12 +11,5 @@ public partial struct NormalizedShort2
     /// <summary>
     /// Provides optimized overrides for bulk operations.
     /// </summary>
-    internal class PixelOperations : PixelOperations<NormalizedShort2>
-    {
-        private static readonly Lazy<PixelTypeInfo> LazyInfo =
-            new Lazy<PixelTypeInfo>(() => PixelTypeInfo.Create<NormalizedShort2>(PixelAlphaRepresentation.None), true);
-
-        /// <inheritdoc />
-        public override PixelTypeInfo GetPixelTypeInfo() => LazyInfo.Value;
-    }
+    internal class PixelOperations : PixelOperations<NormalizedShort2>;
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/NormalizedShort4.PixelOperations.cs b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/NormalizedShort4.PixelOperations.cs
index 6334f4e7e..ad6aa8d8a 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/NormalizedShort4.PixelOperations.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/NormalizedShort4.PixelOperations.cs
@@ -1,8 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using SixLabors.ImageSharp.Formats;
-
 namespace SixLabors.ImageSharp.PixelFormats;
 
 /// <content>
@@ -13,12 +11,5 @@ public partial struct NormalizedShort4
     /// <summary>
     /// Provides optimized overrides for bulk operations.
     /// </summary>
-    internal class PixelOperations : PixelOperations<NormalizedShort4>
-    {
-        private static readonly Lazy<PixelTypeInfo> LazyInfo =
-            new Lazy<PixelTypeInfo>(() => PixelTypeInfo.Create<NormalizedShort4>(PixelAlphaRepresentation.Unassociated), true);
-
-        /// <inheritdoc />
-        public override PixelTypeInfo GetPixelTypeInfo() => LazyInfo.Value;
-    }
+    internal class PixelOperations : PixelOperations<NormalizedShort4>;
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Rg32.PixelOperations.cs b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Rg32.PixelOperations.cs
index a5b803f76..7bca1c781 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Rg32.PixelOperations.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Rg32.PixelOperations.cs
@@ -1,8 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using SixLabors.ImageSharp.Formats;
-
 namespace SixLabors.ImageSharp.PixelFormats;
 
 /// <content>
@@ -13,12 +11,5 @@ public partial struct Rg32
     /// <summary>
     /// Provides optimized overrides for bulk operations.
     /// </summary>
-    internal class PixelOperations : PixelOperations<Rg32>
-    {
-        private static readonly Lazy<PixelTypeInfo> LazyInfo =
-            new Lazy<PixelTypeInfo>(() => PixelTypeInfo.Create<Rg32>(PixelAlphaRepresentation.None), true);
-
-        /// <inheritdoc />
-        public override PixelTypeInfo GetPixelTypeInfo() => LazyInfo.Value;
-    }
+    internal class PixelOperations : PixelOperations<Rg32>;
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Rgb24.PixelOperations.cs b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Rgb24.PixelOperations.cs
index 5473a602f..435a8c077 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Rgb24.PixelOperations.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Rgb24.PixelOperations.cs
@@ -1,8 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using SixLabors.ImageSharp.Formats;
-
 namespace SixLabors.ImageSharp.PixelFormats;
 
 /// <content>
@@ -15,12 +13,6 @@ public partial struct Rgb24
     /// </summary>
     internal partial class PixelOperations : PixelOperations<Rgb24>
     {
-        private static readonly Lazy<PixelTypeInfo> LazyInfo =
-            new(() => PixelTypeInfo.Create<Rgb24>(PixelAlphaRepresentation.None), true);
-
-        /// <inheritdoc />
-        public override PixelTypeInfo GetPixelTypeInfo() => LazyInfo.Value;
-
         /// <inheritdoc />
         internal override void PackFromRgbPlanes(
             ReadOnlySpan<byte> redChannel,
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Rgb48.PixelOperations.cs b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Rgb48.PixelOperations.cs
index 56a052a7d..c9ed730c4 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Rgb48.PixelOperations.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Rgb48.PixelOperations.cs
@@ -1,8 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using SixLabors.ImageSharp.Formats;
-
 namespace SixLabors.ImageSharp.PixelFormats;
 
 /// <content>
@@ -13,12 +11,5 @@ public partial struct Rgb48
     /// <summary>
     /// Provides optimized overrides for bulk operations.
     /// </summary>
-    internal partial class PixelOperations : PixelOperations<Rgb48>
-    {
-        private static readonly Lazy<PixelTypeInfo> LazyInfo =
-            new Lazy<PixelTypeInfo>(() => PixelTypeInfo.Create<Rgb48>(PixelAlphaRepresentation.None), true);
-
-        /// <inheritdoc />
-        public override PixelTypeInfo GetPixelTypeInfo() => LazyInfo.Value;
-    }
+    internal partial class PixelOperations : PixelOperations<Rgb48>;
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Rgba1010102.PixelOperations.cs b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Rgba1010102.PixelOperations.cs
index f55039627..8dcbb319f 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Rgba1010102.PixelOperations.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Rgba1010102.PixelOperations.cs
@@ -1,8 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using SixLabors.ImageSharp.Formats;
-
 namespace SixLabors.ImageSharp.PixelFormats;
 
 /// <content>
@@ -13,12 +11,5 @@ public partial struct Rgba1010102
     /// <summary>
     /// Provides optimized overrides for bulk operations.
     /// </summary>
-    internal class PixelOperations : PixelOperations<Rgba1010102>
-    {
-        private static readonly Lazy<PixelTypeInfo> LazyInfo =
-            new Lazy<PixelTypeInfo>(() => PixelTypeInfo.Create<Rgba1010102>(PixelAlphaRepresentation.Unassociated), true);
-
-        /// <inheritdoc />
-        public override PixelTypeInfo GetPixelTypeInfo() => LazyInfo.Value;
-    }
+    internal class PixelOperations : PixelOperations<Rgba1010102>;
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Rgba32.PixelOperations.cs b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Rgba32.PixelOperations.cs
index a4887b393..ed89585dc 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Rgba32.PixelOperations.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Rgba32.PixelOperations.cs
@@ -3,7 +3,6 @@
 
 using System.Numerics;
 using System.Runtime.InteropServices;
-using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.PixelFormats.Utils;
 
 namespace SixLabors.ImageSharp.PixelFormats;
@@ -18,12 +17,6 @@ public partial struct Rgba32
     /// </summary>
     internal partial class PixelOperations : PixelOperations<Rgba32>
     {
-        private static readonly Lazy<PixelTypeInfo> LazyInfo =
-            new(() => PixelTypeInfo.Create<Rgba32>(PixelAlphaRepresentation.Unassociated), true);
-
-        /// <inheritdoc />
-        public override PixelTypeInfo GetPixelTypeInfo() => LazyInfo.Value;
-
         /// <inheritdoc />
         public override void ToVector4(
             Configuration configuration,
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Rgba64.PixelOperations.cs b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Rgba64.PixelOperations.cs
index 56bbc6b25..6b362d44e 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Rgba64.PixelOperations.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Rgba64.PixelOperations.cs
@@ -1,8 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using SixLabors.ImageSharp.Formats;
-
 namespace SixLabors.ImageSharp.PixelFormats;
 
 /// <content>
@@ -13,12 +11,5 @@ public partial struct Rgba64
     /// <summary>
     /// Provides optimized overrides for bulk operations.
     /// </summary>
-    internal partial class PixelOperations : PixelOperations<Rgba64>
-    {
-        private static readonly Lazy<PixelTypeInfo> LazyInfo =
-            new Lazy<PixelTypeInfo>(() => PixelTypeInfo.Create<Rgba64>(PixelAlphaRepresentation.Unassociated), true);
-
-        /// <inheritdoc />
-        public override PixelTypeInfo GetPixelTypeInfo() => LazyInfo.Value;
-    }
+    internal partial class PixelOperations : PixelOperations<Rgba64>;
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/RgbaVector.PixelOperations.cs b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/RgbaVector.PixelOperations.cs
index a3833583f..5f9b51af9 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/RgbaVector.PixelOperations.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/RgbaVector.PixelOperations.cs
@@ -2,9 +2,7 @@
 // Licensed under the Six Labors Split License.
 
 using System.Numerics;
-using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
-using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.PixelFormats.Utils;
 
 namespace SixLabors.ImageSharp.PixelFormats;
@@ -19,12 +17,6 @@ public partial struct RgbaVector
     /// </summary>
     internal class PixelOperations : PixelOperations<RgbaVector>
     {
-        private static readonly Lazy<PixelTypeInfo> LazyInfo =
-            new(() => PixelTypeInfo.Create<RgbaVector>(PixelAlphaRepresentation.Unassociated), true);
-
-        /// <inheritdoc />
-        public override PixelTypeInfo GetPixelTypeInfo() => LazyInfo.Value;
-
         /// <inheritdoc />
         public override void From<TSourcePixel>(
             Configuration configuration,
@@ -61,43 +53,5 @@ public partial struct RgbaVector
             MemoryMarshal.Cast<RgbaVector, Vector4>(sourcePixels).CopyTo(destinationVectors);
             Vector4Converters.ApplyForwardConversionModifiers(destinationVectors, modifiers);
         }
-
-        public override void ToL8(
-            Configuration configuration,
-            ReadOnlySpan<RgbaVector> sourcePixels,
-            Span<L8> destinationPixels)
-        {
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
-
-            ref Vector4 sourceBaseRef = ref Unsafe.As<RgbaVector, Vector4>(ref MemoryMarshal.GetReference(sourcePixels));
-            ref L8 destBaseRef = ref MemoryMarshal.GetReference(destinationPixels);
-
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
-            {
-                ref Vector4 sp = ref Unsafe.Add(ref sourceBaseRef, i);
-                ref L8 dp = ref Unsafe.Add(ref destBaseRef, i);
-
-                dp.ConvertFromRgbaScaledVector4(sp);
-            }
-        }
-
-        public override void ToL16(
-            Configuration configuration,
-            ReadOnlySpan<RgbaVector> sourcePixels,
-            Span<L16> destinationPixels)
-        {
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
-
-            ref Vector4 sourceBaseRef = ref Unsafe.As<RgbaVector, Vector4>(ref MemoryMarshal.GetReference(sourcePixels));
-            ref L16 destBaseRef = ref MemoryMarshal.GetReference(destinationPixels);
-
-            for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
-            {
-                ref Vector4 sp = ref Unsafe.Add(ref sourceBaseRef, i);
-                ref L16 dp = ref Unsafe.Add(ref destBaseRef, i);
-
-                dp.ConvertFromRgbaScaledVector4(sp);
-            }
-        }
     }
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Short2.PixelOperations.cs b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Short2.PixelOperations.cs
index 435a521ba..d8225f18a 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Short2.PixelOperations.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Short2.PixelOperations.cs
@@ -1,8 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using SixLabors.ImageSharp.Formats;
-
 namespace SixLabors.ImageSharp.PixelFormats;
 
 /// <content>
@@ -13,12 +11,5 @@ public partial struct Short2
     /// <summary>
     /// Provides optimized overrides for bulk operations.
     /// </summary>
-    internal class PixelOperations : PixelOperations<Short2>
-    {
-        private static readonly Lazy<PixelTypeInfo> LazyInfo =
-            new Lazy<PixelTypeInfo>(() => PixelTypeInfo.Create<Short2>(PixelAlphaRepresentation.None), true);
-
-        /// <inheritdoc />
-        public override PixelTypeInfo GetPixelTypeInfo() => LazyInfo.Value;
-    }
+    internal class PixelOperations : PixelOperations<Short2>;
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Short4.PixelOperations.cs b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Short4.PixelOperations.cs
index 546da9c57..3d7043b0c 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Short4.PixelOperations.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Short4.PixelOperations.cs
@@ -1,8 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using SixLabors.ImageSharp.Formats;
-
 namespace SixLabors.ImageSharp.PixelFormats;
 
 /// <content>
@@ -13,12 +11,5 @@ public partial struct Short4
     /// <summary>
     /// Provides optimized overrides for bulk operations.
     /// </summary>
-    internal class PixelOperations : PixelOperations<Short4>
-    {
-        private static readonly Lazy<PixelTypeInfo> LazyInfo =
-            new Lazy<PixelTypeInfo>(() => PixelTypeInfo.Create<Short4>(PixelAlphaRepresentation.Unassociated), true);
-
-        /// <inheritdoc />
-        public override PixelTypeInfo GetPixelTypeInfo() => LazyInfo.Value;
-    }
+    internal class PixelOperations : PixelOperations<Short4>;
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Rg32.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Rg32.cs
index 0a13a15ed..e7c97269e 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Rg32.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Rg32.cs
@@ -43,7 +43,7 @@ public partial struct Rg32 : IPixel<Rg32>, IPackedVector<uint>
     /// <returns>
     /// True if the <paramref name="left"/> parameter is equal to the <paramref name="right"/> parameter; otherwise, false.
     /// </returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator ==(Rg32 left, Rg32 right) => left.Equals(right);
 
     /// <summary>
@@ -54,115 +54,121 @@ public partial struct Rg32 : IPixel<Rg32>, IPackedVector<uint>
     /// <returns>
     /// True if the <paramref name="left"/> parameter is not equal to the <paramref name="right"/> parameter; otherwise, false.
     /// </returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator !=(Rg32 left, Rg32 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public readonly PixelOperations<Rg32> CreatePixelOperations() => new PixelOperations();
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly Rgba32 ToRgba32()
+        => new(
+            ColorNumerics.From16BitTo8Bit((ushort)(this.PackedValue & 0xFFFF)),
+            ColorNumerics.From16BitTo8Bit((ushort)(this.PackedValue >> 16)),
+            byte.MinValue,
+            byte.MaxValue);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromScaledVector4(Vector4 vector) => this.FromVector4(vector);
-
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public readonly Vector4 ToScaledVector4() => this.ToVector4();
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromVector4(Vector4 vector)
-    {
-        var vector2 = new Vector2(vector.X, vector.Y);
-        this.PackedValue = Pack(vector2);
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly Vector4 ToVector4() => new(this.ToVector2(), 0f, 1f);
+
+    /// <inheritdoc />
+    public static PixelTypeInfo GetPixelTypeInfo()
+        => PixelTypeInfo.Create<Rg32>(
+            PixelComponentInfo.Create<Rg32>(2, 16, 16),
+            PixelColorType.Red | PixelColorType.Green,
+            PixelAlphaRepresentation.None);
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public readonly Vector4 ToVector4() => new(this.ToVector2(), 0F, 1F);
+    public static PixelOperations<Rg32> CreatePixelOperations() => new PixelOperations();
+
+    /// <inheritdoc/>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rg32 FromScaledVector4(Vector4 source) => FromVector4(source);
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromArgb32(Argb32 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rg32 FromVector4(Vector4 source) => new() { PackedValue = Pack(new Vector2(source.X, source.Y)) };
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgr24(Bgr24 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rg32 FromAbgr32(Abgr32 source) => new(ColorNumerics.From8BitTo16Bit(source.R), ColorNumerics.From8BitTo16Bit(source.G));
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgra32(Bgra32 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rg32 FromArgb32(Argb32 source) => new(ColorNumerics.From8BitTo16Bit(source.R), ColorNumerics.From8BitTo16Bit(source.G));
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromAbgr32(Abgr32 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rg32 FromBgra5551(Bgra5551 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgra5551(Bgra5551 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rg32 FromBgr24(Bgr24 source) => new(ColorNumerics.From8BitTo16Bit(source.R), ColorNumerics.From8BitTo16Bit(source.G));
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromL8(L8 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rg32 FromBgra32(Bgra32 source) => new(ColorNumerics.From8BitTo16Bit(source.R), ColorNumerics.From8BitTo16Bit(source.G));
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromL16(L16 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rg32 FromL8(L8 source) => new(ColorNumerics.From8BitTo16Bit(source.PackedValue), ColorNumerics.From8BitTo16Bit(source.PackedValue));
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromLa16(La16 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rg32 FromL16(L16 source) => new(source.PackedValue, source.PackedValue);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromLa32(La32 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rg32 FromLa16(La16 source) => new(ColorNumerics.From8BitTo16Bit(source.L), ColorNumerics.From8BitTo16Bit(source.L));
 
-    /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgb24(Rgb24 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc/>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rg32 FromLa32(La32 source) => new(source.L, source.L);
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgba32(Rgba32 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rg32 FromRgb24(Rgb24 source) => new(ColorNumerics.From8BitTo16Bit(source.R), ColorNumerics.From8BitTo16Bit(source.G));
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void ToRgba32(ref Rgba32 dest) => dest.FromScaledVector4(this.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rg32 FromRgba32(Rgba32 source) => new(ColorNumerics.From8BitTo16Bit(source.R), ColorNumerics.From8BitTo16Bit(source.G));
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgb48(Rgb48 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rg32 FromRgb48(Rgb48 source) => new(source.R, source.G);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgba64(Rgba64 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rg32 FromRgba64(Rgba64 source) => new(source.R, source.G);
 
     /// <summary>
     /// Expands the packed representation into a <see cref="Vector2"/>.
     /// The vector components are typically expanded in least to greatest significance order.
     /// </summary>
     /// <returns>The <see cref="Vector2"/>.</returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public readonly Vector2 ToVector2() => new Vector2(this.PackedValue & 0xFFFF, (this.PackedValue >> 16) & 0xFFFF) / Max;
 
     /// <inheritdoc />
     public override readonly bool Equals(object? obj) => obj is Rg32 other && this.Equals(other);
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
     public readonly bool Equals(Rg32 other) => this.PackedValue.Equals(other.PackedValue);
 
     /// <inheritdoc />
     public override readonly string ToString()
     {
-        var vector = this.ToVector2();
+        Vector2 vector = this.ToVector2();
         return FormattableString.Invariant($"Rg32({vector.X:#0.##}, {vector.Y:#0.##})");
     }
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
     public override readonly int GetHashCode() => this.PackedValue.GetHashCode();
 
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static uint Pack(Vector2 vector)
     {
         vector = Vector2.Clamp(vector, Vector2.Zero, Vector2.One) * Max;
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Rgb24.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Rgb24.cs
index 105618cd9..ac855d47d 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Rgb24.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Rgb24.cs
@@ -4,6 +4,7 @@
 using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics;
 
 namespace SixLabors.ImageSharp.PixelFormats;
 
@@ -35,8 +36,8 @@ public partial struct Rgb24 : IPixel<Rgb24>
     [FieldOffset(2)]
     public byte B;
 
-    private static readonly Vector4 MaxBytes = new(byte.MaxValue);
-    private static readonly Vector4 Half = new(0.5F);
+    private static readonly Vector4 MaxBytes = Vector128.Create(255f).AsVector4();
+    private static readonly Vector4 Half = Vector128.Create(.5f).AsVector4();
 
     /// <summary>
     /// Initializes a new instance of the <see cref="Rgb24"/> struct.
@@ -44,7 +45,7 @@ public partial struct Rgb24 : IPixel<Rgb24>
     /// <param name="r">The red component.</param>
     /// <param name="g">The green component.</param>
     /// <param name="b">The blue component.</param>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public Rgb24(byte r, byte g, byte b)
     {
         this.R = r;
@@ -52,37 +53,14 @@ public partial struct Rgb24 : IPixel<Rgb24>
         this.B = b;
     }
 
-    /// <summary>
-    /// Converts an <see cref="Rgb24"/> to <see cref="Color"/>.
-    /// </summary>
-    /// <param name="source">The <see cref="Rgb24"/>.</param>
-    /// <returns>The <see cref="Color"/>.</returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public static implicit operator Color(Rgb24 source) => new(source);
-
-    /// <summary>
-    /// Converts a <see cref="Color"/> to <see cref="Rgb24"/>.
-    /// </summary>
-    /// <param name="color">The <see cref="Color"/>.</param>
-    /// <returns>The <see cref="Rgb24"/>.</returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public static implicit operator Rgb24(Color color) => color.ToRgb24();
-
     /// <summary>
     /// Allows the implicit conversion of an instance of <see cref="ColorSpaces.Rgb"/> to a
     /// <see cref="Rgb24"/>.
     /// </summary>
     /// <param name="color">The instance of <see cref="ColorSpaces.Rgb"/> to convert.</param>
     /// <returns>An instance of <see cref="Rgb24"/>.</returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public static implicit operator Rgb24(ColorSpaces.Rgb color)
-    {
-        var vector = new Vector4(color.ToVector3(), 1F);
-
-        Rgb24 rgb = default;
-        rgb.FromScaledVector4(vector);
-        return rgb;
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static implicit operator Rgb24(ColorSpaces.Rgb color) => FromScaledVector4(new Vector4(color.ToVector3(), 1f));
 
     /// <summary>
     /// Compares two <see cref="Rgb24"/> objects for equality.
@@ -92,7 +70,7 @@ public partial struct Rgb24 : IPixel<Rgb24>
     /// <returns>
     /// True if the <paramref name="left"/> parameter is equal to the <paramref name="right"/> parameter; otherwise, false.
     /// </returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator ==(Rgb24 left, Rgb24 right) => left.Equals(right);
 
     /// <summary>
@@ -103,169 +81,128 @@ public partial struct Rgb24 : IPixel<Rgb24>
     /// <returns>
     /// True if the <paramref name="left"/> parameter is not equal to the <paramref name="right"/> parameter; otherwise, false.
     /// </returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator !=(Rgb24 left, Rgb24 right) => !left.Equals(right);
 
-    /// <inheritdoc/>
-    public readonly PixelOperations<Rgb24> CreatePixelOperations() => new PixelOperations();
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly Rgba32 ToRgba32() => Rgba32.FromRgb24(this);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromScaledVector4(Vector4 vector) => this.FromVector4(vector);
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly Vector4 ToScaledVector4() => this.ToVector4();
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public readonly Vector4 ToScaledVector4() => this.ToVector4();
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly Vector4 ToVector4() => new Rgba32(this.R, this.G, this.B, byte.MaxValue).ToVector4();
+
+    /// <inheritdoc />
+    public static PixelTypeInfo GetPixelTypeInfo()
+        => PixelTypeInfo.Create<Rgb24>(
+            PixelComponentInfo.Create<Rgb24>(3, 8, 8, 8),
+            PixelColorType.RGB,
+            PixelAlphaRepresentation.None);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromVector4(Vector4 vector) => this.Pack(ref vector);
+    public static PixelOperations<Rgb24> CreatePixelOperations() => new PixelOperations();
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public readonly Vector4 ToVector4() => new Rgba32(this.R, this.G, this.B, byte.MaxValue).ToVector4();
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rgb24 FromScaledVector4(Vector4 source) => FromVector4(source);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromArgb32(Argb32 source)
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rgb24 FromVector4(Vector4 source)
     {
-        this.R = source.R;
-        this.G = source.G;
-        this.B = source.B;
+        source *= MaxBytes;
+        source += Half;
+        source = Numerics.Clamp(source, Vector4.Zero, MaxBytes);
+
+        Vector128<byte> result = Vector128.ConvertToInt32(source.AsVector128()).AsByte();
+        return new(result.GetElement(0), result.GetElement(4), result.GetElement(8));
     }
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgr24(Bgr24 source)
-    {
-        this.R = source.R;
-        this.G = source.G;
-        this.B = source.B;
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rgb24 FromAbgr32(Abgr32 source) => new(source.R, source.G, source.B);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgra32(Bgra32 source)
-    {
-        this.R = source.R;
-        this.G = source.G;
-        this.B = source.B;
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rgb24 FromArgb32(Argb32 source) => new(source.R, source.G, source.B);
+
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rgb24 FromBgra5551(Bgra5551 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromAbgr32(Abgr32 source)
-    {
-        this.R = source.R;
-        this.G = source.G;
-        this.B = source.B;
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rgb24 FromBgr24(Bgr24 source) => new(source.R, source.G, source.B);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromL8(L8 source)
-    {
-        this.R = source.PackedValue;
-        this.G = source.PackedValue;
-        this.B = source.PackedValue;
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rgb24 FromBgra32(Bgra32 source) => new(source.R, source.G, source.B);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromL16(L16 source)
-    {
-        byte rgb = ColorNumerics.DownScaleFrom16BitTo8Bit(source.PackedValue);
-        this.R = rgb;
-        this.G = rgb;
-        this.B = rgb;
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rgb24 FromL8(L8 source) => new(source.PackedValue, source.PackedValue, source.PackedValue);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromLa16(La16 source)
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rgb24 FromL16(L16 source)
     {
-        this.R = source.L;
-        this.G = source.L;
-        this.B = source.L;
+        byte rgb = ColorNumerics.From16BitTo8Bit(source.PackedValue);
+        return new(rgb, rgb, rgb);
     }
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromLa32(La32 source)
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rgb24 FromLa16(La16 source) => new(source.L, source.L, source.L);
+
+    /// <inheritdoc/>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rgb24 FromLa32(La32 source)
     {
-        byte rgb = ColorNumerics.DownScaleFrom16BitTo8Bit(source.L);
-        this.R = rgb;
-        this.G = rgb;
-        this.B = rgb;
+        byte rgb = ColorNumerics.From16BitTo8Bit(source.L);
+        return new(rgb, rgb, rgb);
     }
 
-    /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgra5551(Bgra5551 source) => this.FromScaledVector4(source.ToScaledVector4());
-
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgb24(Rgb24 source) => this = source;
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rgb24 FromRgb24(Rgb24 source) => new(source.R, source.G, source.B);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgba32(Rgba32 source) => this = source.Rgb;
-
-    /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void ToRgba32(ref Rgba32 dest)
-    {
-        dest.R = this.R;
-        dest.G = this.G;
-        dest.B = this.B;
-        dest.A = byte.MaxValue;
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rgb24 FromRgba32(Rgba32 source) => new(source.R, source.G, source.B);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgb48(Rgb48 source)
-    {
-        this.R = ColorNumerics.DownScaleFrom16BitTo8Bit(source.R);
-        this.G = ColorNumerics.DownScaleFrom16BitTo8Bit(source.G);
-        this.B = ColorNumerics.DownScaleFrom16BitTo8Bit(source.B);
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rgb24 FromRgb48(Rgb48 source)
+        => new()
+        {
+            R = ColorNumerics.From16BitTo8Bit(source.R),
+            G = ColorNumerics.From16BitTo8Bit(source.G),
+            B = ColorNumerics.From16BitTo8Bit(source.B)
+        };
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgba64(Rgba64 source)
-    {
-        this.R = ColorNumerics.DownScaleFrom16BitTo8Bit(source.R);
-        this.G = ColorNumerics.DownScaleFrom16BitTo8Bit(source.G);
-        this.B = ColorNumerics.DownScaleFrom16BitTo8Bit(source.B);
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rgb24 FromRgba64(Rgba64 source)
+        => new()
+        {
+            R = ColorNumerics.From16BitTo8Bit(source.R),
+            G = ColorNumerics.From16BitTo8Bit(source.G),
+            B = ColorNumerics.From16BitTo8Bit(source.B)
+        };
 
     /// <inheritdoc/>
     public override readonly bool Equals(object? obj) => obj is Rgb24 other && this.Equals(other);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
     public readonly bool Equals(Rgb24 other) => this.R.Equals(other.R) && this.G.Equals(other.G) && this.B.Equals(other.B);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
     public override readonly int GetHashCode() => HashCode.Combine(this.R, this.B, this.G);
 
     /// <inheritdoc/>
     public override readonly string ToString() => $"Rgb24({this.R}, {this.G}, {this.B})";
-
-    /// <summary>
-    /// Packs a <see cref="Vector4"/> into a color.
-    /// </summary>
-    /// <param name="vector">The vector containing the values to pack.</param>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    private void Pack(ref Vector4 vector)
-    {
-        vector *= MaxBytes;
-        vector += Half;
-        vector = Numerics.Clamp(vector, Vector4.Zero, MaxBytes);
-
-        this.R = (byte)vector.X;
-        this.G = (byte)vector.Y;
-        this.B = (byte)vector.Z;
-    }
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Rgb48.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Rgb48.cs
index 6bf25717c..e822d2abc 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Rgb48.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Rgb48.cs
@@ -55,7 +55,7 @@ public partial struct Rgb48 : IPixel<Rgb48>
     /// <returns>
     /// True if the <paramref name="left"/> parameter is equal to the <paramref name="right"/> parameter; otherwise, false.
     /// </returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator ==(Rgb48 left, Rgb48 right) => left.Equals(right);
 
     /// <summary>
@@ -66,159 +66,118 @@ public partial struct Rgb48 : IPixel<Rgb48>
     /// <returns>
     /// True if the <paramref name="left"/> parameter is not equal to the <paramref name="right"/> parameter; otherwise, false.
     /// </returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator !=(Rgb48 left, Rgb48 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public readonly PixelOperations<Rgb48> CreatePixelOperations() => new PixelOperations();
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly Rgba32 ToRgba32() => Rgba32.FromRgb48(this);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromScaledVector4(Vector4 vector) => this.FromVector4(vector);
-
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public readonly Vector4 ToScaledVector4() => this.ToVector4();
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromVector4(Vector4 vector)
-    {
-        vector = Numerics.Clamp(vector, Vector4.Zero, Vector4.One) * Max;
-        this.R = (ushort)MathF.Round(vector.X);
-        this.G = (ushort)MathF.Round(vector.Y);
-        this.B = (ushort)MathF.Round(vector.Z);
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly Vector4 ToVector4() => new(this.R / Max, this.G / Max, this.B / Max, 1f);
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public readonly Vector4 ToVector4() => new(this.R / Max, this.G / Max, this.B / Max, 1F);
+    public static PixelTypeInfo GetPixelTypeInfo()
+        => PixelTypeInfo.Create<Rgb48>(
+            PixelComponentInfo.Create<Rgb48>(3, 16, 16, 16),
+            PixelColorType.RGB,
+            PixelAlphaRepresentation.None);
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromArgb32(Argb32 source)
-    {
-        this.R = ColorNumerics.UpscaleFrom8BitTo16Bit(source.R);
-        this.G = ColorNumerics.UpscaleFrom8BitTo16Bit(source.G);
-        this.B = ColorNumerics.UpscaleFrom8BitTo16Bit(source.B);
-    }
+    public static PixelOperations<Rgb48> CreatePixelOperations() => new PixelOperations();
+
+    /// <inheritdoc/>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rgb48 FromScaledVector4(Vector4 source) => FromVector4(source);
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgr24(Bgr24 source)
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rgb48 FromVector4(Vector4 source)
     {
-        this.R = ColorNumerics.UpscaleFrom8BitTo16Bit(source.R);
-        this.G = ColorNumerics.UpscaleFrom8BitTo16Bit(source.G);
-        this.B = ColorNumerics.UpscaleFrom8BitTo16Bit(source.B);
+        source = Numerics.Clamp(source, Vector4.Zero, Vector4.One) * Max;
+        return new((ushort)MathF.Round(source.X), (ushort)MathF.Round(source.Y), (ushort)MathF.Round(source.Z));
     }
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgra32(Bgra32 source)
-    {
-        this.R = ColorNumerics.UpscaleFrom8BitTo16Bit(source.R);
-        this.G = ColorNumerics.UpscaleFrom8BitTo16Bit(source.G);
-        this.B = ColorNumerics.UpscaleFrom8BitTo16Bit(source.B);
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rgb48 FromAbgr32(Abgr32 source)
+        => new(ColorNumerics.From8BitTo16Bit(source.R), ColorNumerics.From8BitTo16Bit(source.G), ColorNumerics.From8BitTo16Bit(source.B));
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgba64(Rgba64 source) => this = source.Rgb;
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rgb48 FromArgb32(Argb32 source)
+        => new(ColorNumerics.From8BitTo16Bit(source.R), ColorNumerics.From8BitTo16Bit(source.G), ColorNumerics.From8BitTo16Bit(source.B));
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgra5551(Bgra5551 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rgb48 FromBgra5551(Bgra5551 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromL8(L8 source)
-    {
-        ushort rgb = ColorNumerics.UpscaleFrom8BitTo16Bit(source.PackedValue);
-        this.R = rgb;
-        this.G = rgb;
-        this.B = rgb;
-    }
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rgb48 FromBgr24(Bgr24 source)
+        => new(ColorNumerics.From8BitTo16Bit(source.R), ColorNumerics.From8BitTo16Bit(source.G), ColorNumerics.From8BitTo16Bit(source.B));
+
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rgb48 FromBgra32(Bgra32 source)
+        => new(ColorNumerics.From8BitTo16Bit(source.R), ColorNumerics.From8BitTo16Bit(source.G), ColorNumerics.From8BitTo16Bit(source.B));
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromL16(L16 source)
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rgb48 FromL8(L8 source)
     {
-        this.R = source.PackedValue;
-        this.G = source.PackedValue;
-        this.B = source.PackedValue;
+        ushort rgb = ColorNumerics.From8BitTo16Bit(source.PackedValue);
+        return new(rgb, rgb, rgb);
     }
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromLa16(La16 source)
-    {
-        ushort rgb = ColorNumerics.UpscaleFrom8BitTo16Bit(source.L);
-        this.R = rgb;
-        this.G = rgb;
-        this.B = rgb;
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rgb48 FromL16(L16 source) => new(source.PackedValue, source.PackedValue, source.PackedValue);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromLa32(La32 source)
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rgb48 FromLa16(La16 source)
     {
-        this.R = source.L;
-        this.G = source.L;
-        this.B = source.L;
+        ushort rgb = ColorNumerics.From8BitTo16Bit(source.L);
+        return new(rgb, rgb, rgb);
     }
 
-    /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgb24(Rgb24 source)
-    {
-        this.R = ColorNumerics.UpscaleFrom8BitTo16Bit(source.R);
-        this.G = ColorNumerics.UpscaleFrom8BitTo16Bit(source.G);
-        this.B = ColorNumerics.UpscaleFrom8BitTo16Bit(source.B);
-    }
+    /// <inheritdoc/>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rgb48 FromLa32(La32 source) => new(source.L, source.L, source.L);
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgba32(Rgba32 source)
-    {
-        this.R = ColorNumerics.UpscaleFrom8BitTo16Bit(source.R);
-        this.G = ColorNumerics.UpscaleFrom8BitTo16Bit(source.G);
-        this.B = ColorNumerics.UpscaleFrom8BitTo16Bit(source.B);
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rgb48 FromRgb24(Rgb24 source)
+        => new(ColorNumerics.From8BitTo16Bit(source.R), ColorNumerics.From8BitTo16Bit(source.G), ColorNumerics.From8BitTo16Bit(source.B));
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromAbgr32(Abgr32 source)
-    {
-        this.R = ColorNumerics.UpscaleFrom8BitTo16Bit(source.R);
-        this.G = ColorNumerics.UpscaleFrom8BitTo16Bit(source.G);
-        this.B = ColorNumerics.UpscaleFrom8BitTo16Bit(source.B);
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rgb48 FromRgba32(Rgba32 source)
+        => new(ColorNumerics.From8BitTo16Bit(source.R), ColorNumerics.From8BitTo16Bit(source.G), ColorNumerics.From8BitTo16Bit(source.B));
 
-    /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void ToRgba32(ref Rgba32 dest)
-    {
-        dest.R = ColorNumerics.DownScaleFrom16BitTo8Bit(this.R);
-        dest.G = ColorNumerics.DownScaleFrom16BitTo8Bit(this.G);
-        dest.B = ColorNumerics.DownScaleFrom16BitTo8Bit(this.B);
-        dest.A = byte.MaxValue;
-    }
+    /// <inheritdoc/>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rgb48 FromRgb48(Rgb48 source) => new(source.R, source.G, source.B);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgb48(Rgb48 source) => this = source;
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rgb48 FromRgba64(Rgba64 source) => new(source.R, source.G, source.B);
 
     /// <inheritdoc />
     public override readonly bool Equals(object? obj) => obj is Rgb48 rgb48 && this.Equals(rgb48);
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
     public readonly bool Equals(Rgb48 other) => this.R.Equals(other.R) && this.G.Equals(other.G) && this.B.Equals(other.B);
 
     /// <inheritdoc />
     public override readonly string ToString() => $"Rgb48({this.R}, {this.G}, {this.B})";
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
     public override readonly int GetHashCode() => HashCode.Combine(this.R, this.G, this.B);
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Rgba1010102.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Rgba1010102.cs
index 7bac1d920..cdee22964 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Rgba1010102.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Rgba1010102.cs
@@ -7,7 +7,7 @@ using System.Runtime.CompilerServices;
 namespace SixLabors.ImageSharp.PixelFormats;
 
 /// <summary>
-/// Packed vector type containing unsigned normalized values ranging from 0 to 1.
+/// Packed vector type containing 4 unsigned normalized values ranging from 0 to 1.
 /// The x, y and z components use 10 bits, and the w component uses 2 bits.
 /// <para>
 /// Ranges from [0, 0, 0, 0] to [1, 1, 1, 1] in vector form.
@@ -33,7 +33,7 @@ public partial struct Rgba1010102 : IPixel<Rgba1010102>, IPackedVector<uint>
     /// Initializes a new instance of the <see cref="Rgba1010102"/> struct.
     /// </summary>
     /// <param name="vector">The vector containing the component values.</param>
-    public Rgba1010102(Vector4 vector) => this.PackedValue = Pack(ref vector);
+    public Rgba1010102(Vector4 vector) => this.PackedValue = Pack(vector);
 
     /// <inheritdoc/>
     public uint PackedValue { get; set; }
@@ -46,7 +46,7 @@ public partial struct Rgba1010102 : IPixel<Rgba1010102>, IPackedVector<uint>
     /// <returns>
     /// True if the <paramref name="left"/> parameter is equal to the <paramref name="right"/> parameter; otherwise, false.
     /// </returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator ==(Rgba1010102 left, Rgba1010102 right) => left.Equals(right);
 
     /// <summary>
@@ -57,26 +57,19 @@ public partial struct Rgba1010102 : IPixel<Rgba1010102>, IPackedVector<uint>
     /// <returns>
     /// True if the <paramref name="left"/> parameter is not equal to the <paramref name="right"/> parameter; otherwise, false.
     /// </returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator !=(Rgba1010102 left, Rgba1010102 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public readonly PixelOperations<Rgba1010102> CreatePixelOperations() => new PixelOperations();
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly Rgba32 ToRgba32() => Rgba32.FromScaledVector4(this.ToScaledVector4());
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromScaledVector4(Vector4 vector) => this.FromVector4(vector);
-
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public readonly Vector4 ToScaledVector4() => this.ToVector4();
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromVector4(Vector4 vector) => this.PackedValue = Pack(ref vector);
-
-    /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public readonly Vector4 ToVector4() => new Vector4(
             (this.PackedValue >> 0) & 0x03FF,
             (this.PackedValue >> 10) & 0x03FF,
@@ -84,81 +77,93 @@ public partial struct Rgba1010102 : IPixel<Rgba1010102>, IPackedVector<uint>
             (this.PackedValue >> 30) & 0x03) / Multiplier;
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromArgb32(Argb32 source) => this.FromScaledVector4(source.ToScaledVector4());
+    public static PixelTypeInfo GetPixelTypeInfo()
+        => PixelTypeInfo.Create<Rgba1010102>(
+            PixelComponentInfo.Create<Rgba1010102>(4, 10, 10, 10, 2),
+            PixelColorType.RGB | PixelColorType.Alpha,
+            PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgr24(Bgr24 source) => this.FromScaledVector4(source.ToScaledVector4());
+    public static PixelOperations<Rgba1010102> CreatePixelOperations() => new PixelOperations();
+
+    /// <inheritdoc/>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rgba1010102 FromScaledVector4(Vector4 source) => FromVector4(source);
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgra32(Bgra32 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rgba1010102 FromVector4(Vector4 source) => new() { PackedValue = Pack(source) };
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromAbgr32(Abgr32 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rgba1010102 FromAbgr32(Abgr32 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgra5551(Bgra5551 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rgba1010102 FromArgb32(Argb32 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromL8(L8 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rgba1010102 FromBgra5551(Bgra5551 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromL16(L16 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rgba1010102 FromBgr24(Bgr24 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromLa16(La16 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rgba1010102 FromBgra32(Bgra32 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromLa32(La32 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rgba1010102 FromL8(L8 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgb24(Rgb24 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rgba1010102 FromL16(L16 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgba32(Rgba32 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rgba1010102 FromLa16(La16 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void ToRgba32(ref Rgba32 dest) => dest.FromScaledVector4(this.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rgba1010102 FromLa32(La32 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgb48(Rgb48 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rgba1010102 FromRgb24(Rgb24 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgba64(Rgba64 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rgba1010102 FromRgba32(Rgba32 source) => FromScaledVector4(source.ToScaledVector4());
+
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rgba1010102 FromRgb48(Rgb48 source) => FromScaledVector4(source.ToScaledVector4());
+
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rgba1010102 FromRgba64(Rgba64 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc />
     public override readonly bool Equals(object? obj) => obj is Rgba1010102 other && this.Equals(other);
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
     public readonly bool Equals(Rgba1010102 other) => this.PackedValue == other.PackedValue;
 
     /// <inheritdoc />
     public override readonly string ToString()
     {
-        var vector = this.ToVector4();
+        Vector4 vector = this.ToVector4();
         return FormattableString.Invariant($"Rgba1010102({vector.X:#0.##}, {vector.Y:#0.##}, {vector.Z:#0.##}, {vector.W:#0.##})");
     }
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
     public override readonly int GetHashCode() => this.PackedValue.GetHashCode();
 
-    [MethodImpl(InliningOptions.ShortMethod)]
-    private static uint Pack(ref Vector4 vector)
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static uint Pack(Vector4 vector)
     {
         vector = Numerics.Clamp(vector, Vector4.Zero, Vector4.One) * Multiplier;
 
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Rgba32.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Rgba32.cs
index 75fe8f3f4..fc347c166 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Rgba32.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Rgba32.cs
@@ -6,6 +6,7 @@ using System.Globalization;
 using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics;
 
 namespace SixLabors.ImageSharp.PixelFormats;
 
@@ -43,8 +44,8 @@ public partial struct Rgba32 : IPixel<Rgba32>, IPackedVector<uint>
     /// </summary>
     public byte A;
 
-    private static readonly Vector4 MaxBytes = new(byte.MaxValue);
-    private static readonly Vector4 Half = new(0.5F);
+    private static readonly Vector4 MaxBytes = Vector128.Create(255f).AsVector4();
+    private static readonly Vector4 Half = Vector128.Create(.5f).AsVector4();
 
     /// <summary>
     /// Initializes a new instance of the <see cref="Rgba32"/> struct.
@@ -52,7 +53,7 @@ public partial struct Rgba32 : IPixel<Rgba32>, IPackedVector<uint>
     /// <param name="r">The red component.</param>
     /// <param name="g">The green component.</param>
     /// <param name="b">The blue component.</param>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public Rgba32(byte r, byte g, byte b)
     {
         this.R = r;
@@ -68,7 +69,7 @@ public partial struct Rgba32 : IPixel<Rgba32>, IPackedVector<uint>
     /// <param name="g">The green component.</param>
     /// <param name="b">The blue component.</param>
     /// <param name="a">The alpha component.</param>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public Rgba32(byte r, byte g, byte b, byte a)
     {
         this.R = r;
@@ -84,9 +85,11 @@ public partial struct Rgba32 : IPixel<Rgba32>, IPackedVector<uint>
     /// <param name="g">The green component.</param>
     /// <param name="b">The blue component.</param>
     /// <param name="a">The alpha component.</param>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public Rgba32(float r, float g, float b, float a = 1)
-        : this() => this.Pack(r, g, b, a);
+        : this(new Vector4(r, g, b, a))
+    {
+    }
 
     /// <summary>
     /// Initializes a new instance of the <see cref="Rgba32"/> struct.
@@ -94,9 +97,11 @@ public partial struct Rgba32 : IPixel<Rgba32>, IPackedVector<uint>
     /// <param name="vector">
     /// The vector containing the components for the packed vector.
     /// </param>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public Rgba32(Vector3 vector)
-        : this() => this.Pack(ref vector);
+        : this(new Vector4(vector, 1f))
+    {
+    }
 
     /// <summary>
     /// Initializes a new instance of the <see cref="Rgba32"/> struct.
@@ -104,9 +109,9 @@ public partial struct Rgba32 : IPixel<Rgba32>, IPackedVector<uint>
     /// <param name="vector">
     /// The vector containing the components for the packed vector.
     /// </param>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public Rgba32(Vector4 vector)
-        : this() => this = PackNew(ref vector);
+        : this() => this = Pack(vector);
 
     /// <summary>
     /// Initializes a new instance of the <see cref="Rgba32"/> struct.
@@ -114,7 +119,7 @@ public partial struct Rgba32 : IPixel<Rgba32>, IPackedVector<uint>
     /// <param name="packed">
     /// The packed value.
     /// </param>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public Rgba32(uint packed)
         : this() => this.Rgba = packed;
 
@@ -123,10 +128,10 @@ public partial struct Rgba32 : IPixel<Rgba32>, IPackedVector<uint>
     /// </summary>
     public uint Rgba
     {
-        [MethodImpl(InliningOptions.ShortMethod)]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         readonly get => Unsafe.As<Rgba32, uint>(ref Unsafe.AsRef(in this));
 
-        [MethodImpl(InliningOptions.ShortMethod)]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         set => Unsafe.As<Rgba32, uint>(ref this) = value;
     }
 
@@ -135,10 +140,10 @@ public partial struct Rgba32 : IPixel<Rgba32>, IPackedVector<uint>
     /// </summary>
     public Rgb24 Rgb
     {
-        [MethodImpl(InliningOptions.ShortMethod)]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         readonly get => new(this.R, this.G, this.B);
 
-        [MethodImpl(InliningOptions.ShortMethod)]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         set
         {
             this.R = value.R;
@@ -152,10 +157,10 @@ public partial struct Rgba32 : IPixel<Rgba32>, IPackedVector<uint>
     /// </summary>
     public Bgr24 Bgr
     {
-        [MethodImpl(InliningOptions.ShortMethod)]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         readonly get => new(this.R, this.G, this.B);
 
-        [MethodImpl(InliningOptions.ShortMethod)]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         set
         {
             this.R = value.R;
@@ -167,44 +172,21 @@ public partial struct Rgba32 : IPixel<Rgba32>, IPackedVector<uint>
     /// <inheritdoc/>
     public uint PackedValue
     {
-        [MethodImpl(InliningOptions.ShortMethod)]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         readonly get => this.Rgba;
 
-        [MethodImpl(InliningOptions.ShortMethod)]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         set => this.Rgba = value;
     }
 
-    /// <summary>
-    /// Converts an <see cref="Rgba32"/> to <see cref="Color"/>.
-    /// </summary>
-    /// <param name="source">The <see cref="Rgba32"/>.</param>
-    /// <returns>The <see cref="Color"/>.</returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public static implicit operator Color(Rgba32 source) => new(source);
-
-    /// <summary>
-    /// Converts a <see cref="Color"/> to <see cref="Rgba32"/>.
-    /// </summary>
-    /// <param name="color">The <see cref="Color"/>.</param>
-    /// <returns>The <see cref="Rgba32"/>.</returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public static implicit operator Rgba32(Color color) => color.ToRgba32();
-
     /// <summary>
     /// Allows the implicit conversion of an instance of <see cref="ColorSpaces.Rgb"/> to a
     /// <see cref="Rgba32"/>.
     /// </summary>
     /// <param name="color">The instance of <see cref="ColorSpaces.Rgb"/> to convert.</param>
     /// <returns>An instance of <see cref="Rgba32"/>.</returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public static implicit operator Rgba32(ColorSpaces.Rgb color)
-    {
-        var vector = new Vector4(color.ToVector3(), 1F);
-
-        Rgba32 rgba = default;
-        rgba.FromScaledVector4(vector);
-        return rgba;
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static implicit operator Rgba32(ColorSpaces.Rgb color) => FromScaledVector4(new Vector4(color.ToVector3(), 1F));
 
     /// <summary>
     /// Compares two <see cref="Rgba32"/> objects for equality.
@@ -214,7 +196,7 @@ public partial struct Rgba32 : IPixel<Rgba32>, IPackedVector<uint>
     /// <returns>
     /// True if the <paramref name="left"/> parameter is equal to the <paramref name="right"/> parameter; otherwise, false.
     /// </returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator ==(Rgba32 left, Rgba32 right) => left.Equals(right);
 
     /// <summary>
@@ -225,7 +207,7 @@ public partial struct Rgba32 : IPixel<Rgba32>, IPackedVector<uint>
     /// <returns>
     /// True if the <paramref name="left"/> parameter is not equal to the <paramref name="right"/> parameter; otherwise, false.
     /// </returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator !=(Rgba32 left, Rgba32 right) => !left.Equals(right);
 
     /// <summary>
@@ -240,7 +222,7 @@ public partial struct Rgba32 : IPixel<Rgba32>, IPackedVector<uint>
     /// The <see cref="Rgba32"/>.
     /// </returns>
     /// <exception cref="ArgumentException">Hexadecimal string is not in the correct format.</exception>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static Rgba32 ParseHex(string hex)
     {
         Guard.NotNull(hex, nameof(hex));
@@ -265,7 +247,7 @@ public partial struct Rgba32 : IPixel<Rgba32>, IPackedVector<uint>
     /// <returns>
     /// The <see cref="bool"/>.
     /// </returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool TryParseHex(string? hex, out Rgba32 result)
     {
         result = default;
@@ -287,143 +269,108 @@ public partial struct Rgba32 : IPixel<Rgba32>, IPackedVector<uint>
     }
 
     /// <inheritdoc />
-    public readonly PixelOperations<Rgba32> CreatePixelOperations() => new PixelOperations();
-
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromScaledVector4(Vector4 vector) => this.FromVector4(vector);
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly Rgba32 ToRgba32() => this;
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public readonly Vector4 ToScaledVector4() => this.ToVector4();
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromVector4(Vector4 vector) => this.Pack(ref vector);
-
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public readonly Vector4 ToVector4() => new Vector4(this.R, this.G, this.B, this.A) / MaxBytes;
 
+    /// <inheritdoc />
+    public static PixelTypeInfo GetPixelTypeInfo()
+        => PixelTypeInfo.Create<Rgba32>(
+            PixelComponentInfo.Create<Rgba32>(4, 8, 8, 8, 8),
+            PixelColorType.RGB | PixelColorType.Alpha,
+            PixelAlphaRepresentation.Unassociated);
+
+    /// <inheritdoc />
+    public static PixelOperations<Rgba32> CreatePixelOperations() => new PixelOperations();
+
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromArgb32(Argb32 source)
-    {
-        this.R = source.R;
-        this.G = source.G;
-        this.B = source.B;
-        this.A = source.A;
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rgba32 FromScaledVector4(Vector4 source) => FromVector4(source);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgr24(Bgr24 source)
-    {
-        this.Bgr = source;
-        this.A = byte.MaxValue;
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rgba32 FromVector4(Vector4 source) => Pack(source);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgra32(Bgra32 source)
-    {
-        this.R = source.R;
-        this.G = source.G;
-        this.B = source.B;
-        this.A = source.A;
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rgba32 FromAbgr32(Abgr32 source) => new(source.R, source.G, source.B, source.A);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromAbgr32(Abgr32 source)
-    {
-        this.R = source.R;
-        this.G = source.G;
-        this.B = source.B;
-        this.A = source.A;
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rgba32 FromArgb32(Argb32 source) => new(source.R, source.G, source.B, source.A);
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgra5551(Bgra5551 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rgba32 FromBgra5551(Bgra5551 source) => FromScaledVector4(source.ToScaledVector4());
+
+    /// <inheritdoc/>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rgba32 FromBgr24(Bgr24 source) => new(source.R, source.G, source.B);
+
+    /// <inheritdoc/>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rgba32 FromBgra32(Bgra32 source) => new(source.R, source.G, source.B, source.A);
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromL8(L8 source)
-    {
-        this.R = source.PackedValue;
-        this.G = source.PackedValue;
-        this.B = source.PackedValue;
-        this.A = byte.MaxValue;
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rgba32 FromL8(L8 source) => new(source.PackedValue, source.PackedValue, source.PackedValue);
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromL16(L16 source)
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rgba32 FromL16(L16 source)
     {
-        byte rgb = ColorNumerics.DownScaleFrom16BitTo8Bit(source.PackedValue);
-        this.R = rgb;
-        this.G = rgb;
-        this.B = rgb;
-        this.A = byte.MaxValue;
+        byte rgb = ColorNumerics.From16BitTo8Bit(source.PackedValue);
+        return new(rgb, rgb, rgb);
     }
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromLa16(La16 source)
-    {
-        this.R = source.L;
-        this.G = source.L;
-        this.B = source.L;
-        this.A = source.A;
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rgba32 FromLa16(La16 source) => new(source.L, source.L, source.L, source.A);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromLa32(La32 source)
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rgba32 FromLa32(La32 source)
     {
-        byte rgb = ColorNumerics.DownScaleFrom16BitTo8Bit(source.L);
-        this.R = rgb;
-        this.G = rgb;
-        this.B = rgb;
-        this.A = ColorNumerics.DownScaleFrom16BitTo8Bit(source.A);
+        byte rgb = ColorNumerics.From16BitTo8Bit(source.L);
+        return new(rgb, rgb, rgb, ColorNumerics.From16BitTo8Bit(source.A));
     }
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgb24(Rgb24 source)
-    {
-        this.Rgb = source;
-        this.A = byte.MaxValue;
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rgba32 FromRgb24(Rgb24 source) => new(source.R, source.G, source.B);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgba32(Rgba32 source) => this = source;
-
-    /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void ToRgba32(ref Rgba32 dest) => dest = this;
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rgba32 FromRgba32(Rgba32 source) => new() { PackedValue = source.PackedValue };
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgb48(Rgb48 source)
-    {
-        this.R = ColorNumerics.DownScaleFrom16BitTo8Bit(source.R);
-        this.G = ColorNumerics.DownScaleFrom16BitTo8Bit(source.G);
-        this.B = ColorNumerics.DownScaleFrom16BitTo8Bit(source.B);
-        this.A = byte.MaxValue;
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rgba32 FromRgb48(Rgb48 source)
+        => new()
+        {
+            R = ColorNumerics.From16BitTo8Bit(source.R),
+            G = ColorNumerics.From16BitTo8Bit(source.G),
+            B = ColorNumerics.From16BitTo8Bit(source.B),
+            A = byte.MaxValue
+        };
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgba64(Rgba64 source)
-    {
-        this.R = ColorNumerics.DownScaleFrom16BitTo8Bit(source.R);
-        this.G = ColorNumerics.DownScaleFrom16BitTo8Bit(source.G);
-        this.B = ColorNumerics.DownScaleFrom16BitTo8Bit(source.B);
-        this.A = ColorNumerics.DownScaleFrom16BitTo8Bit(source.A);
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rgba32 FromRgba64(Rgba64 source)
+        => new()
+        {
+            R = ColorNumerics.From16BitTo8Bit(source.R),
+            G = ColorNumerics.From16BitTo8Bit(source.G),
+            B = ColorNumerics.From16BitTo8Bit(source.B),
+            A = ColorNumerics.From16BitTo8Bit(source.A)
+        };
 
     /// <summary>
     /// Converts the value of this instance to a hexadecimal string.
@@ -439,71 +386,27 @@ public partial struct Rgba32 : IPixel<Rgba32>, IPackedVector<uint>
     public override readonly bool Equals(object? obj) => obj is Rgba32 rgba32 && this.Equals(rgba32);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
     public readonly bool Equals(Rgba32 other) => this.Rgba.Equals(other.Rgba);
 
     /// <inheritdoc/>
     public override readonly string ToString() => $"Rgba32({this.R}, {this.G}, {this.B}, {this.A})";
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
     public override readonly int GetHashCode() => this.Rgba.GetHashCode();
 
-    /// <summary>
-    /// Packs a <see cref="Vector4"/> into a color returning a new instance as a result.
-    /// </summary>
-    /// <param name="vector">The vector containing the values to pack.</param>
-    /// <returns>The <see cref="Rgba32"/></returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    private static Rgba32 PackNew(ref Vector4 vector)
-    {
-        vector *= MaxBytes;
-        vector += Half;
-        vector = Numerics.Clamp(vector, Vector4.Zero, MaxBytes);
-
-        return new Rgba32((byte)vector.X, (byte)vector.Y, (byte)vector.Z, (byte)vector.W);
-    }
-
-    /// <summary>
-    /// Packs the four floats into a color.
-    /// </summary>
-    /// <param name="x">The x-component</param>
-    /// <param name="y">The y-component</param>
-    /// <param name="z">The z-component</param>
-    /// <param name="w">The w-component</param>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    private void Pack(float x, float y, float z, float w)
-    {
-        var value = new Vector4(x, y, z, w);
-        this.Pack(ref value);
-    }
-
-    /// <summary>
-    /// Packs a <see cref="Vector3"/> into a uint.
-    /// </summary>
-    /// <param name="vector">The vector containing the values to pack.</param>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    private void Pack(ref Vector3 vector)
-    {
-        var value = new Vector4(vector, 1F);
-        this.Pack(ref value);
-    }
-
     /// <summary>
     /// Packs a <see cref="Vector4"/> into a color.
     /// </summary>
     /// <param name="vector">The vector containing the values to pack.</param>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    private void Pack(ref Vector4 vector)
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static Rgba32 Pack(Vector4 vector)
     {
         vector *= MaxBytes;
         vector += Half;
         vector = Numerics.Clamp(vector, Vector4.Zero, MaxBytes);
 
-        this.R = (byte)vector.X;
-        this.G = (byte)vector.Y;
-        this.B = (byte)vector.Z;
-        this.A = (byte)vector.W;
+        Vector128<byte> result = Vector128.ConvertToInt32(vector.AsVector128()).AsByte();
+        return new(result.GetElement(0), result.GetElement(4), result.GetElement(8), result.GetElement(12));
     }
 
     /// <summary>
@@ -535,10 +438,10 @@ public partial struct Rgba32 : IPixel<Rgba32>, IPackedVector<uint>
             return null;
         }
 
-        char r = hex[0];
-        char g = hex[1];
-        char b = hex[2];
         char a = hex.Length == 3 ? 'F' : hex[3];
+        char b = hex[2];
+        char g = hex[1];
+        char r = hex[0];
 
         return new string(new[] { r, r, g, g, b, b, a, a });
     }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Rgba64.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Rgba64.cs
index 75235c900..27c4752e1 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Rgba64.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Rgba64.cs
@@ -45,7 +45,7 @@ public partial struct Rgba64 : IPixel<Rgba64>, IPackedVector<ulong>
     /// <param name="g">The green component.</param>
     /// <param name="b">The blue component.</param>
     /// <param name="a">The alpha component.</param>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public Rgba64(ushort r, ushort g, ushort b, ushort a)
     {
         this.R = r;
@@ -58,64 +58,64 @@ public partial struct Rgba64 : IPixel<Rgba64>, IPackedVector<ulong>
     /// Initializes a new instance of the <see cref="Rgba64"/> struct.
     /// </summary>
     /// <param name="source">A structure of 4 bytes in RGBA byte order.</param>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public Rgba64(Rgba32 source)
     {
-        this.R = ColorNumerics.UpscaleFrom8BitTo16Bit(source.R);
-        this.G = ColorNumerics.UpscaleFrom8BitTo16Bit(source.G);
-        this.B = ColorNumerics.UpscaleFrom8BitTo16Bit(source.B);
-        this.A = ColorNumerics.UpscaleFrom8BitTo16Bit(source.A);
+        this.R = ColorNumerics.From8BitTo16Bit(source.R);
+        this.G = ColorNumerics.From8BitTo16Bit(source.G);
+        this.B = ColorNumerics.From8BitTo16Bit(source.B);
+        this.A = ColorNumerics.From8BitTo16Bit(source.A);
     }
 
     /// <summary>
     /// Initializes a new instance of the <see cref="Rgba64"/> struct.
     /// </summary>
     /// <param name="source">A structure of 4 bytes in BGRA byte order.</param>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public Rgba64(Bgra32 source)
     {
-        this.R = ColorNumerics.UpscaleFrom8BitTo16Bit(source.R);
-        this.G = ColorNumerics.UpscaleFrom8BitTo16Bit(source.G);
-        this.B = ColorNumerics.UpscaleFrom8BitTo16Bit(source.B);
-        this.A = ColorNumerics.UpscaleFrom8BitTo16Bit(source.A);
+        this.R = ColorNumerics.From8BitTo16Bit(source.R);
+        this.G = ColorNumerics.From8BitTo16Bit(source.G);
+        this.B = ColorNumerics.From8BitTo16Bit(source.B);
+        this.A = ColorNumerics.From8BitTo16Bit(source.A);
     }
 
     /// <summary>
     /// Initializes a new instance of the <see cref="Rgba64"/> struct.
     /// </summary>
     /// <param name="source">A structure of 4 bytes in ARGB byte order.</param>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public Rgba64(Argb32 source)
     {
-        this.R = ColorNumerics.UpscaleFrom8BitTo16Bit(source.R);
-        this.G = ColorNumerics.UpscaleFrom8BitTo16Bit(source.G);
-        this.B = ColorNumerics.UpscaleFrom8BitTo16Bit(source.B);
-        this.A = ColorNumerics.UpscaleFrom8BitTo16Bit(source.A);
+        this.R = ColorNumerics.From8BitTo16Bit(source.R);
+        this.G = ColorNumerics.From8BitTo16Bit(source.G);
+        this.B = ColorNumerics.From8BitTo16Bit(source.B);
+        this.A = ColorNumerics.From8BitTo16Bit(source.A);
     }
 
     /// <summary>
     /// Initializes a new instance of the <see cref="Rgba64"/> struct.
     /// </summary>
     /// <param name="source">A structure of 4 bytes in ABGR byte order.</param>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public Rgba64(Abgr32 source)
     {
-        this.R = ColorNumerics.UpscaleFrom8BitTo16Bit(source.R);
-        this.G = ColorNumerics.UpscaleFrom8BitTo16Bit(source.G);
-        this.B = ColorNumerics.UpscaleFrom8BitTo16Bit(source.B);
-        this.A = ColorNumerics.UpscaleFrom8BitTo16Bit(source.A);
+        this.R = ColorNumerics.From8BitTo16Bit(source.R);
+        this.G = ColorNumerics.From8BitTo16Bit(source.G);
+        this.B = ColorNumerics.From8BitTo16Bit(source.B);
+        this.A = ColorNumerics.From8BitTo16Bit(source.A);
     }
 
     /// <summary>
     /// Initializes a new instance of the <see cref="Rgba64"/> struct.
     /// </summary>
     /// <param name="source">A structure of 3 bytes in RGB byte order.</param>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public Rgba64(Rgb24 source)
     {
-        this.R = ColorNumerics.UpscaleFrom8BitTo16Bit(source.R);
-        this.G = ColorNumerics.UpscaleFrom8BitTo16Bit(source.G);
-        this.B = ColorNumerics.UpscaleFrom8BitTo16Bit(source.B);
+        this.R = ColorNumerics.From8BitTo16Bit(source.R);
+        this.G = ColorNumerics.From8BitTo16Bit(source.G);
+        this.B = ColorNumerics.From8BitTo16Bit(source.B);
         this.A = ushort.MaxValue;
     }
 
@@ -123,12 +123,12 @@ public partial struct Rgba64 : IPixel<Rgba64>, IPackedVector<ulong>
     /// Initializes a new instance of the <see cref="Rgba64"/> struct.
     /// </summary>
     /// <param name="source">A structure of 3 bytes in BGR byte order.</param>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public Rgba64(Bgr24 source)
     {
-        this.R = ColorNumerics.UpscaleFrom8BitTo16Bit(source.R);
-        this.G = ColorNumerics.UpscaleFrom8BitTo16Bit(source.G);
-        this.B = ColorNumerics.UpscaleFrom8BitTo16Bit(source.B);
+        this.R = ColorNumerics.From8BitTo16Bit(source.R);
+        this.G = ColorNumerics.From8BitTo16Bit(source.G);
+        this.B = ColorNumerics.From8BitTo16Bit(source.B);
         this.A = ushort.MaxValue;
     }
 
@@ -136,7 +136,7 @@ public partial struct Rgba64 : IPixel<Rgba64>, IPackedVector<ulong>
     /// Initializes a new instance of the <see cref="Rgba64"/> struct.
     /// </summary>
     /// <param name="vector">The <see cref="Vector4"/>.</param>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public Rgba64(Vector4 vector)
     {
         vector = Numerics.Clamp(vector, Vector4.Zero, Vector4.One) * Max;
@@ -151,39 +151,23 @@ public partial struct Rgba64 : IPixel<Rgba64>, IPackedVector<ulong>
     /// </summary>
     public Rgb48 Rgb
     {
-        [MethodImpl(InliningOptions.ShortMethod)]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         readonly get => Unsafe.As<Rgba64, Rgb48>(ref Unsafe.AsRef(in this));
 
-        [MethodImpl(InliningOptions.ShortMethod)]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         set => Unsafe.As<Rgba64, Rgb48>(ref this) = value;
     }
 
     /// <inheritdoc/>
     public ulong PackedValue
     {
-        [MethodImpl(InliningOptions.ShortMethod)]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         readonly get => Unsafe.As<Rgba64, ulong>(ref Unsafe.AsRef(in this));
 
-        [MethodImpl(InliningOptions.ShortMethod)]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         set => Unsafe.As<Rgba64, ulong>(ref this) = value;
     }
 
-    /// <summary>
-    /// Converts an <see cref="Rgba64"/> to <see cref="Color"/>.
-    /// </summary>
-    /// <param name="source">The <see cref="Rgba64"/>.</param>
-    /// <returns>The <see cref="Color"/>.</returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public static implicit operator Color(Rgba64 source) => new(source);
-
-    /// <summary>
-    /// Converts a <see cref="Color"/> to <see cref="Rgba64"/>.
-    /// </summary>
-    /// <param name="color">The <see cref="Color"/>.</param>
-    /// <returns>The <see cref="Rgba64"/>.</returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public static implicit operator Rgba64(Color color) => color.ToPixel<Rgba64>();
-
     /// <summary>
     /// Compares two <see cref="Rgba64"/> objects for equality.
     /// </summary>
@@ -192,7 +176,7 @@ public partial struct Rgba64 : IPixel<Rgba64>, IPackedVector<ulong>
     /// <returns>
     /// True if the <paramref name="left"/> parameter is equal to the <paramref name="right"/> parameter; otherwise, false.
     /// </returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator ==(Rgba64 left, Rgba64 right) => left.PackedValue == right.PackedValue;
 
     /// <summary>
@@ -203,256 +187,143 @@ public partial struct Rgba64 : IPixel<Rgba64>, IPackedVector<ulong>
     /// <returns>
     /// True if the <paramref name="left"/> parameter is not equal to the <paramref name="right"/> parameter; otherwise, false.
     /// </returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator !=(Rgba64 left, Rgba64 right) => left.PackedValue != right.PackedValue;
 
     /// <inheritdoc />
-    public readonly PixelOperations<Rgba64> CreatePixelOperations() => new PixelOperations();
-
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromScaledVector4(Vector4 vector) => this.FromVector4(vector);
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly Rgba32 ToRgba32() => Rgba32.FromRgba64(this);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public readonly Vector4 ToScaledVector4() => this.ToVector4();
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromVector4(Vector4 vector)
-    {
-        vector = Numerics.Clamp(vector, Vector4.Zero, Vector4.One) * Max;
-        this.R = (ushort)MathF.Round(vector.X);
-        this.G = (ushort)MathF.Round(vector.Y);
-        this.B = (ushort)MathF.Round(vector.Z);
-        this.A = (ushort)MathF.Round(vector.W);
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly Vector4 ToVector4() => new Vector4(this.R, this.G, this.B, this.A) / Max;
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public readonly Vector4 ToVector4() => new Vector4(this.R, this.G, this.B, this.A) / Max;
+    public static PixelTypeInfo GetPixelTypeInfo()
+        => PixelTypeInfo.Create<Rgba64>(
+            PixelComponentInfo.Create<Rgba64>(4, 16, 16, 16, 16),
+            PixelColorType.RGB | PixelColorType.Alpha,
+            PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromArgb32(Argb32 source)
-    {
-        this.R = ColorNumerics.UpscaleFrom8BitTo16Bit(source.R);
-        this.G = ColorNumerics.UpscaleFrom8BitTo16Bit(source.G);
-        this.B = ColorNumerics.UpscaleFrom8BitTo16Bit(source.B);
-        this.A = ColorNumerics.UpscaleFrom8BitTo16Bit(source.A);
-    }
+    public static PixelOperations<Rgba64> CreatePixelOperations() => new PixelOperations();
+
+    /// <inheritdoc/>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rgba64 FromScaledVector4(Vector4 source) => FromVector4(source);
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgr24(Bgr24 source)
-    {
-        this.R = ColorNumerics.UpscaleFrom8BitTo16Bit(source.R);
-        this.G = ColorNumerics.UpscaleFrom8BitTo16Bit(source.G);
-        this.B = ColorNumerics.UpscaleFrom8BitTo16Bit(source.B);
-        this.A = ushort.MaxValue;
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rgba64 FromVector4(Vector4 source) => new(source);
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgra32(Bgra32 source)
-    {
-        this.R = ColorNumerics.UpscaleFrom8BitTo16Bit(source.R);
-        this.G = ColorNumerics.UpscaleFrom8BitTo16Bit(source.G);
-        this.B = ColorNumerics.UpscaleFrom8BitTo16Bit(source.B);
-        this.A = ColorNumerics.UpscaleFrom8BitTo16Bit(source.A);
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rgba64 FromAbgr32(Abgr32 source) => new(source);
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromAbgr32(Abgr32 source)
-    {
-        this.R = ColorNumerics.UpscaleFrom8BitTo16Bit(source.R);
-        this.G = ColorNumerics.UpscaleFrom8BitTo16Bit(source.G);
-        this.B = ColorNumerics.UpscaleFrom8BitTo16Bit(source.B);
-        this.A = ColorNumerics.UpscaleFrom8BitTo16Bit(source.A);
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rgba64 FromArgb32(Argb32 source) => new(source);
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgra5551(Bgra5551 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rgba64 FromBgra5551(Bgra5551 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromL8(L8 source)
-    {
-        ushort rgb = ColorNumerics.UpscaleFrom8BitTo16Bit(source.PackedValue);
-        this.R = rgb;
-        this.G = rgb;
-        this.B = rgb;
-        this.A = ushort.MaxValue;
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rgba64 FromBgr24(Bgr24 source) => new(source);
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromL16(L16 source)
-    {
-        this.R = source.PackedValue;
-        this.G = source.PackedValue;
-        this.B = source.PackedValue;
-        this.A = ushort.MaxValue;
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rgba64 FromBgra32(Bgra32 source) => new(source);
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromLa16(La16 source)
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rgba64 FromL8(L8 source)
     {
-        ushort rgb = ColorNumerics.UpscaleFrom8BitTo16Bit(source.L);
-        this.R = rgb;
-        this.G = rgb;
-        this.B = rgb;
-        this.A = ColorNumerics.UpscaleFrom8BitTo16Bit(source.A);
+        ushort rgb = ColorNumerics.From8BitTo16Bit(source.PackedValue);
+        return new(rgb, rgb, rgb, ushort.MaxValue);
     }
 
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rgba64 FromL16(L16 source) => new(source.PackedValue, source.PackedValue, source.PackedValue, ushort.MaxValue);
+
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromLa32(La32 source)
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rgba64 FromLa16(La16 source)
     {
-        this.R = source.L;
-        this.G = source.L;
-        this.B = source.L;
-        this.A = source.A;
+        ushort rgb = ColorNumerics.From8BitTo16Bit(source.L);
+        return new(rgb, rgb, rgb, ColorNumerics.From8BitTo16Bit(source.A));
     }
 
-    /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgb24(Rgb24 source)
-    {
-        this.R = ColorNumerics.UpscaleFrom8BitTo16Bit(source.R);
-        this.G = ColorNumerics.UpscaleFrom8BitTo16Bit(source.G);
-        this.B = ColorNumerics.UpscaleFrom8BitTo16Bit(source.B);
-        this.A = ushort.MaxValue;
-    }
+    /// <inheritdoc/>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rgba64 FromLa32(La32 source) => new(source.L, source.L, source.L, source.A);
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgba32(Rgba32 source)
-    {
-        this.R = ColorNumerics.UpscaleFrom8BitTo16Bit(source.R);
-        this.G = ColorNumerics.UpscaleFrom8BitTo16Bit(source.G);
-        this.B = ColorNumerics.UpscaleFrom8BitTo16Bit(source.B);
-        this.A = ColorNumerics.UpscaleFrom8BitTo16Bit(source.A);
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rgba64 FromRgb24(Rgb24 source) => new(source);
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void ToRgba32(ref Rgba32 dest)
-    {
-        dest.R = ColorNumerics.DownScaleFrom16BitTo8Bit(this.R);
-        dest.G = ColorNumerics.DownScaleFrom16BitTo8Bit(this.G);
-        dest.B = ColorNumerics.DownScaleFrom16BitTo8Bit(this.B);
-        dest.A = ColorNumerics.DownScaleFrom16BitTo8Bit(this.A);
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rgba64 FromRgba32(Rgba32 source) => new(source);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgb48(Rgb48 source)
-    {
-        this.Rgb = source;
-        this.A = ushort.MaxValue;
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rgba64 FromRgb48(Rgb48 source) => new(source.R, source.G, source.B, ushort.MaxValue);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgba64(Rgba64 source) => this = source;
-
-    /// <summary>
-    /// Convert to <see cref="Rgba32"/>.
-    /// </summary>
-    /// <returns>The <see cref="Rgba32"/>.</returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public readonly Rgba32 ToRgba32()
-    {
-        byte r = ColorNumerics.DownScaleFrom16BitTo8Bit(this.R);
-        byte g = ColorNumerics.DownScaleFrom16BitTo8Bit(this.G);
-        byte b = ColorNumerics.DownScaleFrom16BitTo8Bit(this.B);
-        byte a = ColorNumerics.DownScaleFrom16BitTo8Bit(this.A);
-        return new Rgba32(r, g, b, a);
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rgba64 FromRgba64(Rgba64 source) => new(source.R, source.G, source.B, source.A);
 
     /// <summary>
     /// Convert to <see cref="Bgra32"/>.
     /// </summary>
     /// <returns>The <see cref="Bgra32"/>.</returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public readonly Bgra32 ToBgra32()
-    {
-        byte r = ColorNumerics.DownScaleFrom16BitTo8Bit(this.R);
-        byte g = ColorNumerics.DownScaleFrom16BitTo8Bit(this.G);
-        byte b = ColorNumerics.DownScaleFrom16BitTo8Bit(this.B);
-        byte a = ColorNumerics.DownScaleFrom16BitTo8Bit(this.A);
-        return new Bgra32(r, g, b, a);
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly Bgra32 ToBgra32() => Bgra32.FromRgba64(this);
 
     /// <summary>
     /// Convert to <see cref="Argb32"/>.
     /// </summary>
     /// <returns>The <see cref="Argb32"/>.</returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public readonly Argb32 ToArgb32()
-    {
-        byte r = ColorNumerics.DownScaleFrom16BitTo8Bit(this.R);
-        byte g = ColorNumerics.DownScaleFrom16BitTo8Bit(this.G);
-        byte b = ColorNumerics.DownScaleFrom16BitTo8Bit(this.B);
-        byte a = ColorNumerics.DownScaleFrom16BitTo8Bit(this.A);
-        return new Argb32(r, g, b, a);
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly Argb32 ToArgb32() => Argb32.FromRgba64(this);
 
     /// <summary>
     /// Convert to <see cref="Abgr32"/>.
     /// </summary>
     /// <returns>The <see cref="Abgr32"/>.</returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public readonly Abgr32 ToAbgr32()
-    {
-        byte r = ColorNumerics.DownScaleFrom16BitTo8Bit(this.R);
-        byte g = ColorNumerics.DownScaleFrom16BitTo8Bit(this.G);
-        byte b = ColorNumerics.DownScaleFrom16BitTo8Bit(this.B);
-        byte a = ColorNumerics.DownScaleFrom16BitTo8Bit(this.A);
-        return new Abgr32(r, g, b, a);
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly Abgr32 ToAbgr32() => Abgr32.FromRgba64(this);
 
     /// <summary>
     /// Convert to <see cref="Rgb24"/>.
     /// </summary>
     /// <returns>The <see cref="Rgb24"/>.</returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public readonly Rgb24 ToRgb24()
-    {
-        byte r = ColorNumerics.DownScaleFrom16BitTo8Bit(this.R);
-        byte g = ColorNumerics.DownScaleFrom16BitTo8Bit(this.G);
-        byte b = ColorNumerics.DownScaleFrom16BitTo8Bit(this.B);
-        return new Rgb24(r, g, b);
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly Rgb24 ToRgb24() => Rgb24.FromRgba64(this);
 
     /// <summary>
     /// Convert to <see cref="Bgr24"/>.
     /// </summary>
     /// <returns>The <see cref="Bgr24"/>.</returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public readonly Bgr24 ToBgr24()
-    {
-        byte r = ColorNumerics.DownScaleFrom16BitTo8Bit(this.R);
-        byte g = ColorNumerics.DownScaleFrom16BitTo8Bit(this.G);
-        byte b = ColorNumerics.DownScaleFrom16BitTo8Bit(this.B);
-        return new Bgr24(r, g, b);
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly Bgr24 ToBgr24() => Bgr24.FromRgba64(this);
 
     /// <inheritdoc />
     public override readonly bool Equals(object? obj) => obj is Rgba64 rgba64 && this.Equals(rgba64);
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
     public readonly bool Equals(Rgba64 other) => this.PackedValue.Equals(other.PackedValue);
 
     /// <inheritdoc />
     public override readonly string ToString() => $"Rgba64({this.R}, {this.G}, {this.B}, {this.A})";
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
     public override readonly int GetHashCode() => this.PackedValue.GetHashCode();
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/RgbaVector.cs b/src/ImageSharp/PixelFormats/PixelImplementations/RgbaVector.cs
index 899987b71..a27cffad8 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/RgbaVector.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/RgbaVector.cs
@@ -53,7 +53,7 @@ public partial struct RgbaVector : IPixel<RgbaVector>
     /// <param name="g">The green component.</param>
     /// <param name="b">The blue component.</param>
     /// <param name="a">The alpha component.</param>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public RgbaVector(float r, float g, float b, float a = 1)
     {
         this.R = r;
@@ -70,7 +70,7 @@ public partial struct RgbaVector : IPixel<RgbaVector>
     /// <returns>
     /// True if the <paramref name="left"/> parameter is equal to the <paramref name="right"/> parameter; otherwise, false.
     /// </returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator ==(RgbaVector left, RgbaVector right) => left.Equals(right);
 
     /// <summary>
@@ -81,102 +81,106 @@ public partial struct RgbaVector : IPixel<RgbaVector>
     /// <returns>
     /// True if the <paramref name="left"/> parameter is not equal to the <paramref name="right"/> parameter; otherwise, false.
     /// </returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator !=(RgbaVector left, RgbaVector right) => !left.Equals(right);
 
-    /// <summary>
-    /// Creates a new instance of the <see cref="RgbaVector"/> struct.
-    /// </summary>
-    /// <param name="hex">
-    /// The hexadecimal representation of the combined color components arranged
-    /// in rgb, rgba, rrggbb, or rrggbbaa format to match web syntax.
-    /// </param>
-    /// <returns>
-    /// The <see cref="RgbaVector"/>.
-    /// </returns>
-    public static RgbaVector FromHex(string hex) => Color.ParseHex(hex).ToPixel<RgbaVector>();
-
     /// <inheritdoc />
-    public readonly PixelOperations<RgbaVector> CreatePixelOperations() => new PixelOperations();
-
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromScaledVector4(Vector4 vector) => this.FromVector4(vector);
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly Rgba32 ToRgba32() => Rgba32.FromScaledVector4(this.ToScaledVector4());
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public readonly Vector4 ToScaledVector4() => this.ToVector4();
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromVector4(Vector4 vector)
-    {
-        vector = Numerics.Clamp(vector, Vector4.Zero, Vector4.One);
-        this.R = vector.X;
-        this.G = vector.Y;
-        this.B = vector.Z;
-        this.A = vector.W;
-    }
-
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public readonly Vector4 ToVector4() => new(this.R, this.G, this.B, this.A);
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromArgb32(Argb32 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    public static PixelTypeInfo GetPixelTypeInfo()
+        => PixelTypeInfo.Create<RgbaVector>(
+            PixelComponentInfo.Create<RgbaVector>(4, 32, 32, 32, 32),
+            PixelColorType.RGB | PixelColorType.Alpha,
+            PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgr24(Bgr24 source) => this.FromScaledVector4(source.ToScaledVector4());
+    public static PixelOperations<RgbaVector> CreatePixelOperations() => new PixelOperations();
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgra32(Bgra32 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static RgbaVector FromScaledVector4(Vector4 source) => FromVector4(source);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromAbgr32(Abgr32 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static RgbaVector FromVector4(Vector4 source)
+    {
+        source = Numerics.Clamp(source, Vector4.Zero, Vector4.One);
+        return new(source.X, source.Y, source.Z, source.W);
+    }
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgra5551(Bgra5551 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static RgbaVector FromAbgr32(Abgr32 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromL8(L8 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static RgbaVector FromArgb32(Argb32 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromL16(L16 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static RgbaVector FromBgra5551(Bgra5551 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromLa16(La16 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static RgbaVector FromBgr24(Bgr24 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromLa32(La32 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static RgbaVector FromBgra32(Bgra32 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgb24(Rgb24 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static RgbaVector FromL8(L8 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgba32(Rgba32 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static RgbaVector FromL16(L16 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void ToRgba32(ref Rgba32 dest) => dest.FromScaledVector4(this.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static RgbaVector FromLa16(La16 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgb48(Rgb48 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static RgbaVector FromLa32(La32 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgba64(Rgba64 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static RgbaVector FromRgb24(Rgb24 source) => FromScaledVector4(source.ToScaledVector4());
+
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static RgbaVector FromRgba32(Rgba32 source) => FromScaledVector4(source.ToScaledVector4());
+
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static RgbaVector FromRgb48(Rgb48 source) => FromScaledVector4(source.ToScaledVector4());
+
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static RgbaVector FromRgba64(Rgba64 source) => FromScaledVector4(source.ToScaledVector4());
+
+    /// <summary>
+    /// Creates a new instance of the <see cref="RgbaVector"/> struct.
+    /// </summary>
+    /// <param name="hex">
+    /// The hexadecimal representation of the combined color components arranged
+    /// in rgb, rgba, rrggbb, or rrggbbaa format to match web syntax.
+    /// </param>
+    /// <returns>
+    /// The <see cref="RgbaVector"/>.
+    /// </returns>
+    public static RgbaVector FromHex(string hex) => Color.ParseHex(hex).ToPixel<RgbaVector>();
 
     /// <summary>
     /// Converts the value of this instance to a hexadecimal string.
@@ -195,7 +199,6 @@ public partial struct RgbaVector : IPixel<RgbaVector>
     public override readonly bool Equals(object? obj) => obj is RgbaVector other && this.Equals(other);
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
     public readonly bool Equals(RgbaVector other) =>
         this.R.Equals(other.R)
         && this.G.Equals(other.G)
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Short2.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Short2.cs
index 832e8c770..403d3fbea 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Short2.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Short2.cs
@@ -50,7 +50,7 @@ public partial struct Short2 : IPixel<Short2>, IPackedVector<uint>
     /// <returns>
     /// True if the <paramref name="left"/> parameter is not equal to the <paramref name="right"/> parameter; otherwise, false.
     /// </returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator ==(Short2 left, Short2 right) => left.Equals(right);
 
     /// <summary>
@@ -61,126 +61,127 @@ public partial struct Short2 : IPixel<Short2>, IPackedVector<uint>
     /// <returns>
     /// True if the <paramref name="left"/> parameter is not equal to the <paramref name="right"/> parameter; otherwise, false.
     /// </returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator !=(Short2 left, Short2 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public readonly PixelOperations<Short2> CreatePixelOperations() => new PixelOperations();
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly Rgba32 ToRgba32() => Rgba32.FromScaledVector4(this.ToScaledVector4());
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromScaledVector4(Vector4 vector)
-    {
-        Vector2 scaled = new Vector2(vector.X, vector.Y) * 65534F;
-        scaled -= new Vector2(32767F);
-        this.PackedValue = Pack(scaled);
-    }
-
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public readonly Vector4 ToScaledVector4()
     {
-        var scaled = this.ToVector2();
-        scaled += new Vector2(32767F);
+        Vector2 scaled = this.ToVector2();
+        scaled += new Vector2(32767f);
         scaled /= 65534F;
-        return new Vector4(scaled, 0F, 1F);
+        return new Vector4(scaled, 0f, 1f);
     }
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromVector4(Vector4 vector)
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly Vector4 ToVector4() => new((short)(this.PackedValue & 0xFFFF), (short)(this.PackedValue >> 0x10), 0f, 1f);
+
+    /// <inheritdoc />
+    public static PixelTypeInfo GetPixelTypeInfo()
+        => PixelTypeInfo.Create<Short2>(
+            PixelComponentInfo.Create<Short2>(2, 16, 16),
+            PixelColorType.Red | PixelColorType.Green,
+            PixelAlphaRepresentation.None);
+
+    /// <inheritdoc />
+    public static PixelOperations<Short2> CreatePixelOperations() => new PixelOperations();
+
+    /// <inheritdoc/>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Short2 FromScaledVector4(Vector4 source)
     {
-        var vector2 = new Vector2(vector.X, vector.Y);
-        this.PackedValue = Pack(vector2);
+        Vector2 scaled = new Vector2(source.X, source.Y) * 65534F;
+        scaled -= new Vector2(32767F);
+        return new() { PackedValue = Pack(scaled) };
     }
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public readonly Vector4 ToVector4() => new((short)(this.PackedValue & 0xFFFF), (short)(this.PackedValue >> 0x10), 0, 1);
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Short2 FromVector4(Vector4 source) => new() { PackedValue = Pack(new Vector2(source.X, source.Y)) };
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromArgb32(Argb32 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Short2 FromAbgr32(Abgr32 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgr24(Bgr24 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Short2 FromArgb32(Argb32 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgra32(Bgra32 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Short2 FromBgra5551(Bgra5551 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromAbgr32(Abgr32 source) => this.FromScaledVector4(source.ToScaledVector4());
-
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgra5551(Bgra5551 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Short2 FromBgr24(Bgr24 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromL8(L8 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Short2 FromBgra32(Bgra32 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromL16(L16 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Short2 FromL8(L8 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromLa16(La16 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Short2 FromL16(L16 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromLa32(La32 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Short2 FromLa16(La16 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgb24(Rgb24 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Short2 FromLa32(La32 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgba32(Rgba32 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Short2 FromRgb24(Rgb24 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void ToRgba32(ref Rgba32 dest) => dest.FromScaledVector4(this.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Short2 FromRgba32(Rgba32 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgb48(Rgb48 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Short2 FromRgb48(Rgb48 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgba64(Rgba64 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Short2 FromRgba64(Rgba64 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <summary>
     /// Expands the packed representation into a <see cref="Vector2"/>.
     /// The vector components are typically expanded in least to greatest significance order.
     /// </summary>
     /// <returns>The <see cref="Vector2"/>.</returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public readonly Vector2 ToVector2() => new((short)(this.PackedValue & 0xFFFF), (short)(this.PackedValue >> 0x10));
 
     /// <inheritdoc />
     public override readonly bool Equals(object? obj) => obj is Short2 other && this.Equals(other);
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
     public readonly bool Equals(Short2 other) => this.PackedValue.Equals(other.PackedValue);
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
     public override readonly int GetHashCode() => this.PackedValue.GetHashCode();
 
     /// <inheritdoc />
     public override readonly string ToString()
     {
-        var vector = this.ToVector2();
+        Vector2 vector = this.ToVector2();
         return FormattableString.Invariant($"Short2({vector.X:#0.##}, {vector.Y:#0.##})");
     }
 
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static uint Pack(Vector2 vector)
     {
         vector = Vector2.Clamp(vector, Min, Max);
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Short4.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Short4.cs
index c4dc324a1..b6cece2be 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Short4.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Short4.cs
@@ -20,8 +20,8 @@ public partial struct Short4 : IPixel<Short4>, IPackedVector<ulong>
     // Two's complement
     private const float MinNeg = ~(int)MaxPos;
 
-    private static readonly Vector4 Max = new Vector4(MaxPos);
-    private static readonly Vector4 Min = new Vector4(MinNeg);
+    private static readonly Vector4 Max = new(MaxPos);
+    private static readonly Vector4 Min = new(MinNeg);
 
     /// <summary>
     /// Initializes a new instance of the <see cref="Short4"/> struct.
@@ -39,7 +39,7 @@ public partial struct Short4 : IPixel<Short4>, IPackedVector<ulong>
     /// Initializes a new instance of the <see cref="Short4"/> struct.
     /// </summary>
     /// <param name="vector">A vector containing the initial values for the components.</param>
-    public Short4(Vector4 vector) => this.PackedValue = Pack(ref vector);
+    public Short4(Vector4 vector) => this.PackedValue = Pack(vector);
 
     /// <inheritdoc/>
     public ulong PackedValue { get; set; }
@@ -52,7 +52,7 @@ public partial struct Short4 : IPixel<Short4>, IPackedVector<ulong>
     /// <returns>
     /// True if the <paramref name="left"/> parameter is not equal to the <paramref name="right"/> parameter; otherwise, false.
     /// </returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator ==(Short4 left, Short4 right) => left.Equals(right);
 
     /// <summary>
@@ -63,132 +63,131 @@ public partial struct Short4 : IPixel<Short4>, IPackedVector<ulong>
     /// <returns>
     /// True if the <paramref name="left"/> parameter is not equal to the <paramref name="right"/> parameter; otherwise, false.
     /// </returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator !=(Short4 left, Short4 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public readonly PixelOperations<Short4> CreatePixelOperations() => new PixelOperations();
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly Rgba32 ToRgba32() => Rgba32.FromScaledVector4(this.ToScaledVector4());
 
     /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromScaledVector4(Vector4 vector)
-    {
-        vector *= 65534F;
-        vector -= new Vector4(32767F);
-        this.FromVector4(vector);
-    }
-
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public readonly Vector4 ToScaledVector4()
     {
-        var scaled = this.ToVector4();
-        scaled += new Vector4(32767F);
-        scaled /= 65534F;
+        Vector4 scaled = this.ToVector4();
+        scaled += new Vector4(32767f);
+        scaled /= 65534f;
         return scaled;
     }
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromVector4(Vector4 vector) => this.PackedValue = Pack(ref vector);
-
-    /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public readonly Vector4 ToVector4()
-    {
-        return new Vector4(
+        => new(
             (short)(this.PackedValue & 0xFFFF),
             (short)((this.PackedValue >> 0x10) & 0xFFFF),
             (short)((this.PackedValue >> 0x20) & 0xFFFF),
             (short)((this.PackedValue >> 0x30) & 0xFFFF));
+
+    /// <inheritdoc />
+    public static PixelTypeInfo GetPixelTypeInfo()
+        => PixelTypeInfo.Create<Short4>(
+            PixelComponentInfo.Create<Short4>(4, 16, 16, 16, 16),
+            PixelColorType.RGB | PixelColorType.Alpha,
+            PixelAlphaRepresentation.Unassociated);
+
+    /// <inheritdoc />
+    public static PixelOperations<Short4> CreatePixelOperations() => new PixelOperations();
+
+    /// <inheritdoc/>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Short4 FromScaledVector4(Vector4 source)
+    {
+        source *= 65534F;
+        source -= new Vector4(32767F);
+        return FromVector4(source);
     }
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromArgb32(Argb32 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Short4 FromVector4(Vector4 source) => new(source);
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgr24(Bgr24 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Short4 FromAbgr32(Abgr32 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgra32(Bgra32 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Short4 FromArgb32(Argb32 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromAbgr32(Abgr32 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Short4 FromBgra5551(Bgra5551 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromBgra5551(Bgra5551 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Short4 FromBgr24(Bgr24 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromL8(L8 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Short4 FromBgra32(Bgra32 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromL16(L16 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Short4 FromL8(L8 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromLa16(La16 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Short4 FromL16(L16 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromLa32(La32 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Short4 FromLa16(La16 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgb24(Rgb24 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Short4 FromLa32(La32 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgba32(Rgba32 source) => this.FromScaledVector4(source.ToScaledVector4());
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Short4 FromRgb24(Rgb24 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void ToRgba32(ref Rgba32 dest)
-    {
-        dest.FromScaledVector4(this.ToScaledVector4());
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Short4 FromRgba32(Rgba32 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgb48(Rgb48 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Short4 FromRgb48(Rgb48 source) => FromScaledVector4(source.ToScaledVector4());
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void FromRgba64(Rgba64 source) => this.FromScaledVector4(source.ToScaledVector4());
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Short4 FromRgba64(Rgba64 source) => FromScaledVector4(source.ToScaledVector4());
 
     /// <inheritdoc />
     public override readonly bool Equals(object? obj) => obj is Short4 other && this.Equals(other);
 
     /// <inheritdoc />
-    [MethodImpl(InliningOptions.ShortMethod)]
     public readonly bool Equals(Short4 other) => this.PackedValue.Equals(other.PackedValue);
 
     /// <summary>
     /// Gets the hash code for the current instance.
     /// </summary>
     /// <returns>Hash code for the instance.</returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
     public override readonly int GetHashCode() => this.PackedValue.GetHashCode();
 
     /// <inheritdoc />
     public override readonly string ToString()
     {
-        var vector = this.ToVector4();
+        Vector4 vector = this.ToVector4();
         return FormattableString.Invariant($"Short4({vector.X:#0.##}, {vector.Y:#0.##}, {vector.Z:#0.##}, {vector.W:#0.##})");
     }
 
-    [MethodImpl(InliningOptions.ShortMethod)]
-    private static ulong Pack(ref Vector4 vector)
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static ulong Pack(Vector4 vector)
     {
-        vector = Numerics.Clamp(vector, Min, Max);
-
         // Clamp the value between min and max values
+        vector = Numerics.Clamp(vector, Min, Max);
         ulong word4 = ((ulong)Convert.ToInt32(Math.Round(vector.X)) & 0xFFFF) << 0x00;
         ulong word3 = ((ulong)Convert.ToInt32(Math.Round(vector.Y)) & 0xFFFF) << 0x10;
         ulong word2 = ((ulong)Convert.ToInt32(Math.Round(vector.Z)) & 0xFFFF) << 0x20;
diff --git a/src/ImageSharp/PixelFormats/PixelOperations{TPixel}.Generated.cs b/src/ImageSharp/PixelFormats/PixelOperations{TPixel}.Generated.cs
index 7e84bd639..712d43f76 100644
--- a/src/ImageSharp/PixelFormats/PixelOperations{TPixel}.Generated.cs
+++ b/src/ImageSharp/PixelFormats/PixelOperations{TPixel}.Generated.cs
@@ -14,20 +14,17 @@ public partial class PixelOperations<TPixel>
     /// </summary>
     /// <param name="configuration">A <see cref="Configuration"/> to configure internal operations.</param>
     /// <param name="source">The source <see cref="Span{T}"/> of <see cref="Argb32"/> data.</param>
-    /// <param name="destinationPixels">The <see cref="Span{T}"/> to the destination pixels.</param>
-    public virtual void FromArgb32(Configuration configuration, ReadOnlySpan<Argb32> source, Span<TPixel> destinationPixels)
+    /// <param name="destination">The <see cref="Span{T}"/> to the destination pixels.</param>
+    public virtual void FromArgb32(Configuration configuration, ReadOnlySpan<Argb32> source, Span<TPixel> destination)
     {
-        Guard.DestinationShouldNotBeTooShort(source, destinationPixels, nameof(destinationPixels));
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-        ref Argb32 sourceBaseRef = ref MemoryMarshal.GetReference(source);
-        ref TPixel destBaseRef = ref MemoryMarshal.GetReference(destinationPixels);
+        ref Argb32 sourceBase = ref MemoryMarshal.GetReference(source);
+        ref TPixel destinationBase = ref MemoryMarshal.GetReference(destination);
 
         for (nuint i = 0; i < (uint)source.Length; i++)
         {
-            ref Argb32 sp = ref Unsafe.Add(ref sourceBaseRef, i);
-            ref TPixel dp = ref Unsafe.Add(ref destBaseRef, i);
-
-            dp.FromArgb32(sp);
+            Unsafe.Add(ref destinationBase, i) = TPixel.FromArgb32(Unsafe.Add(ref sourceBase, i));
         }
     }
 
@@ -37,48 +34,45 @@ public partial class PixelOperations<TPixel>
     /// </summary>
     /// <param name="configuration">A <see cref="Configuration"/> to configure internal operations.</param>
     /// <param name="sourceBytes">The <see cref="ReadOnlySpan{T}"/> to the source bytes.</param>
-    /// <param name="destinationPixels">The <see cref="Span{T}"/> to the destination pixels.</param>
+    /// <param name="destination">The <see cref="Span{T}"/> to the destination pixels.</param>
     /// <param name="count">The number of pixels to convert.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public void FromArgb32Bytes(Configuration configuration, ReadOnlySpan<byte> sourceBytes, Span<TPixel> destinationPixels, int count)
+    public void FromArgb32Bytes(Configuration configuration, ReadOnlySpan<byte> sourceBytes, Span<TPixel> destination, int count)
     {
-        this.FromArgb32(configuration, MemoryMarshal.Cast<byte, Argb32>(sourceBytes).Slice(0, count), destinationPixels);
+        this.FromArgb32(configuration, MemoryMarshal.Cast<byte, Argb32>(sourceBytes).Slice(0, count), destination);
     }
 
     /// <summary>
-    /// Converts all pixels of the 'sourcePixels` span to a span of <see cref="Argb32"/>-s.
+    /// Converts all pixels of the 'source` span to a span of <see cref="Argb32"/>-s.
     /// </summary>
     /// <param name="configuration">A <see cref="Configuration"/> to configure internal operations</param>
-    /// <param name="sourcePixels">The span of source pixels</param>
-    /// <param name="destinationPixels">The destination span of <see cref="Argb32"/> data.</param>
-    public virtual void ToArgb32(Configuration configuration, ReadOnlySpan<TPixel> sourcePixels, Span<Argb32> destinationPixels)
+    /// <param name="source">The span of source pixels</param>
+    /// <param name="destination">The destination span of <see cref="Argb32"/> data.</param>
+    public virtual void ToArgb32(Configuration configuration, ReadOnlySpan<TPixel> source, Span<Argb32> destination)
     {
-        Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-        ref TPixel sourceBaseRef = ref MemoryMarshal.GetReference(sourcePixels);
-        ref Argb32 destBaseRef = ref MemoryMarshal.GetReference(destinationPixels);
+        ref TPixel sourceBase = ref MemoryMarshal.GetReference(source);
+        ref Argb32 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-        for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+        for (nuint i = 0; i < (uint)source.Length; i++)
         {
-            ref TPixel sp = ref Unsafe.Add(ref sourceBaseRef, i);
-            ref Argb32 dp = ref Unsafe.Add(ref destBaseRef, i);
-
-            dp.FromScaledVector4(sp.ToScaledVector4());
+            Unsafe.Add(ref destinationBase, i) = Argb32.FromScaledVector4(Unsafe.Add(ref sourceBase, i).ToScaledVector4());
         }
     }
 
     /// <summary>
     /// A helper for <see cref="ToArgb32(Configuration, ReadOnlySpan{TPixel}, Span{Argb32})"/> that expects a byte span as destination.
-    /// The layout of the data in 'destBytes' must be compatible with <see cref="Argb32"/> layout.
+    /// The layout of the data in 'destination' must be compatible with <see cref="Argb32"/> layout.
     /// </summary>
     /// <param name="configuration">A <see cref="Configuration"/> to configure internal operations</param>
-    /// <param name="sourcePixels">The <see cref="Span{T}"/> to the source pixels.</param>
-    /// <param name="destBytes">The <see cref="Span{T}"/> to the destination bytes.</param>
+    /// <param name="source">The <see cref="Span{T}"/> to the source pixels.</param>
+    /// <param name="destination">The <see cref="Span{T}"/> to the destination bytes.</param>
     /// <param name="count">The number of pixels to convert.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public void ToArgb32Bytes(Configuration configuration, ReadOnlySpan<TPixel> sourcePixels, Span<byte> destBytes, int count)
+    public void ToArgb32Bytes(Configuration configuration, ReadOnlySpan<TPixel> source, Span<byte> destination, int count)
     {
-        this.ToArgb32(configuration, sourcePixels.Slice(0, count), MemoryMarshal.Cast<byte, Argb32>(destBytes));
+        this.ToArgb32(configuration, source.Slice(0, count), MemoryMarshal.Cast<byte, Argb32>(destination));
     }
 
     /// <summary>
@@ -86,20 +80,17 @@ public partial class PixelOperations<TPixel>
     /// </summary>
     /// <param name="configuration">A <see cref="Configuration"/> to configure internal operations.</param>
     /// <param name="source">The source <see cref="Span{T}"/> of <see cref="Abgr32"/> data.</param>
-    /// <param name="destinationPixels">The <see cref="Span{T}"/> to the destination pixels.</param>
-    public virtual void FromAbgr32(Configuration configuration, ReadOnlySpan<Abgr32> source, Span<TPixel> destinationPixels)
+    /// <param name="destination">The <see cref="Span{T}"/> to the destination pixels.</param>
+    public virtual void FromAbgr32(Configuration configuration, ReadOnlySpan<Abgr32> source, Span<TPixel> destination)
     {
-        Guard.DestinationShouldNotBeTooShort(source, destinationPixels, nameof(destinationPixels));
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-        ref Abgr32 sourceBaseRef = ref MemoryMarshal.GetReference(source);
-        ref TPixel destBaseRef = ref MemoryMarshal.GetReference(destinationPixels);
+        ref Abgr32 sourceBase = ref MemoryMarshal.GetReference(source);
+        ref TPixel destinationBase = ref MemoryMarshal.GetReference(destination);
 
         for (nuint i = 0; i < (uint)source.Length; i++)
         {
-            ref Abgr32 sp = ref Unsafe.Add(ref sourceBaseRef, i);
-            ref TPixel dp = ref Unsafe.Add(ref destBaseRef, i);
-
-            dp.FromAbgr32(sp);
+            Unsafe.Add(ref destinationBase, i) = TPixel.FromAbgr32(Unsafe.Add(ref sourceBase, i));
         }
     }
 
@@ -109,48 +100,45 @@ public partial class PixelOperations<TPixel>
     /// </summary>
     /// <param name="configuration">A <see cref="Configuration"/> to configure internal operations.</param>
     /// <param name="sourceBytes">The <see cref="ReadOnlySpan{T}"/> to the source bytes.</param>
-    /// <param name="destinationPixels">The <see cref="Span{T}"/> to the destination pixels.</param>
+    /// <param name="destination">The <see cref="Span{T}"/> to the destination pixels.</param>
     /// <param name="count">The number of pixels to convert.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public void FromAbgr32Bytes(Configuration configuration, ReadOnlySpan<byte> sourceBytes, Span<TPixel> destinationPixels, int count)
+    public void FromAbgr32Bytes(Configuration configuration, ReadOnlySpan<byte> sourceBytes, Span<TPixel> destination, int count)
     {
-        this.FromAbgr32(configuration, MemoryMarshal.Cast<byte, Abgr32>(sourceBytes).Slice(0, count), destinationPixels);
+        this.FromAbgr32(configuration, MemoryMarshal.Cast<byte, Abgr32>(sourceBytes).Slice(0, count), destination);
     }
 
     /// <summary>
-    /// Converts all pixels of the 'sourcePixels` span to a span of <see cref="Abgr32"/>-s.
+    /// Converts all pixels of the 'source` span to a span of <see cref="Abgr32"/>-s.
     /// </summary>
     /// <param name="configuration">A <see cref="Configuration"/> to configure internal operations</param>
-    /// <param name="sourcePixels">The span of source pixels</param>
-    /// <param name="destinationPixels">The destination span of <see cref="Abgr32"/> data.</param>
-    public virtual void ToAbgr32(Configuration configuration, ReadOnlySpan<TPixel> sourcePixels, Span<Abgr32> destinationPixels)
+    /// <param name="source">The span of source pixels</param>
+    /// <param name="destination">The destination span of <see cref="Abgr32"/> data.</param>
+    public virtual void ToAbgr32(Configuration configuration, ReadOnlySpan<TPixel> source, Span<Abgr32> destination)
     {
-        Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-        ref TPixel sourceBaseRef = ref MemoryMarshal.GetReference(sourcePixels);
-        ref Abgr32 destBaseRef = ref MemoryMarshal.GetReference(destinationPixels);
+        ref TPixel sourceBase = ref MemoryMarshal.GetReference(source);
+        ref Abgr32 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-        for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+        for (nuint i = 0; i < (uint)source.Length; i++)
         {
-            ref TPixel sp = ref Unsafe.Add(ref sourceBaseRef, i);
-            ref Abgr32 dp = ref Unsafe.Add(ref destBaseRef, i);
-
-            dp.FromScaledVector4(sp.ToScaledVector4());
+            Unsafe.Add(ref destinationBase, i) = Abgr32.FromScaledVector4(Unsafe.Add(ref sourceBase, i).ToScaledVector4());
         }
     }
 
     /// <summary>
     /// A helper for <see cref="ToAbgr32(Configuration, ReadOnlySpan{TPixel}, Span{Abgr32})"/> that expects a byte span as destination.
-    /// The layout of the data in 'destBytes' must be compatible with <see cref="Abgr32"/> layout.
+    /// The layout of the data in 'destination' must be compatible with <see cref="Abgr32"/> layout.
     /// </summary>
     /// <param name="configuration">A <see cref="Configuration"/> to configure internal operations</param>
-    /// <param name="sourcePixels">The <see cref="Span{T}"/> to the source pixels.</param>
-    /// <param name="destBytes">The <see cref="Span{T}"/> to the destination bytes.</param>
+    /// <param name="source">The <see cref="Span{T}"/> to the source pixels.</param>
+    /// <param name="destination">The <see cref="Span{T}"/> to the destination bytes.</param>
     /// <param name="count">The number of pixels to convert.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public void ToAbgr32Bytes(Configuration configuration, ReadOnlySpan<TPixel> sourcePixels, Span<byte> destBytes, int count)
+    public void ToAbgr32Bytes(Configuration configuration, ReadOnlySpan<TPixel> source, Span<byte> destination, int count)
     {
-        this.ToAbgr32(configuration, sourcePixels.Slice(0, count), MemoryMarshal.Cast<byte, Abgr32>(destBytes));
+        this.ToAbgr32(configuration, source.Slice(0, count), MemoryMarshal.Cast<byte, Abgr32>(destination));
     }
 
     /// <summary>
@@ -158,20 +146,17 @@ public partial class PixelOperations<TPixel>
     /// </summary>
     /// <param name="configuration">A <see cref="Configuration"/> to configure internal operations.</param>
     /// <param name="source">The source <see cref="Span{T}"/> of <see cref="Bgr24"/> data.</param>
-    /// <param name="destinationPixels">The <see cref="Span{T}"/> to the destination pixels.</param>
-    public virtual void FromBgr24(Configuration configuration, ReadOnlySpan<Bgr24> source, Span<TPixel> destinationPixels)
+    /// <param name="destination">The <see cref="Span{T}"/> to the destination pixels.</param>
+    public virtual void FromBgr24(Configuration configuration, ReadOnlySpan<Bgr24> source, Span<TPixel> destination)
     {
-        Guard.DestinationShouldNotBeTooShort(source, destinationPixels, nameof(destinationPixels));
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-        ref Bgr24 sourceBaseRef = ref MemoryMarshal.GetReference(source);
-        ref TPixel destBaseRef = ref MemoryMarshal.GetReference(destinationPixels);
+        ref Bgr24 sourceBase = ref MemoryMarshal.GetReference(source);
+        ref TPixel destinationBase = ref MemoryMarshal.GetReference(destination);
 
         for (nuint i = 0; i < (uint)source.Length; i++)
         {
-            ref Bgr24 sp = ref Unsafe.Add(ref sourceBaseRef, i);
-            ref TPixel dp = ref Unsafe.Add(ref destBaseRef, i);
-
-            dp.FromBgr24(sp);
+            Unsafe.Add(ref destinationBase, i) = TPixel.FromBgr24(Unsafe.Add(ref sourceBase, i));
         }
     }
 
@@ -181,48 +166,45 @@ public partial class PixelOperations<TPixel>
     /// </summary>
     /// <param name="configuration">A <see cref="Configuration"/> to configure internal operations.</param>
     /// <param name="sourceBytes">The <see cref="ReadOnlySpan{T}"/> to the source bytes.</param>
-    /// <param name="destinationPixels">The <see cref="Span{T}"/> to the destination pixels.</param>
+    /// <param name="destination">The <see cref="Span{T}"/> to the destination pixels.</param>
     /// <param name="count">The number of pixels to convert.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public void FromBgr24Bytes(Configuration configuration, ReadOnlySpan<byte> sourceBytes, Span<TPixel> destinationPixels, int count)
+    public void FromBgr24Bytes(Configuration configuration, ReadOnlySpan<byte> sourceBytes, Span<TPixel> destination, int count)
     {
-        this.FromBgr24(configuration, MemoryMarshal.Cast<byte, Bgr24>(sourceBytes).Slice(0, count), destinationPixels);
+        this.FromBgr24(configuration, MemoryMarshal.Cast<byte, Bgr24>(sourceBytes).Slice(0, count), destination);
     }
 
     /// <summary>
-    /// Converts all pixels of the 'sourcePixels` span to a span of <see cref="Bgr24"/>-s.
+    /// Converts all pixels of the 'source` span to a span of <see cref="Bgr24"/>-s.
     /// </summary>
     /// <param name="configuration">A <see cref="Configuration"/> to configure internal operations</param>
-    /// <param name="sourcePixels">The span of source pixels</param>
-    /// <param name="destinationPixels">The destination span of <see cref="Bgr24"/> data.</param>
-    public virtual void ToBgr24(Configuration configuration, ReadOnlySpan<TPixel> sourcePixels, Span<Bgr24> destinationPixels)
+    /// <param name="source">The span of source pixels</param>
+    /// <param name="destination">The destination span of <see cref="Bgr24"/> data.</param>
+    public virtual void ToBgr24(Configuration configuration, ReadOnlySpan<TPixel> source, Span<Bgr24> destination)
     {
-        Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-        ref TPixel sourceBaseRef = ref MemoryMarshal.GetReference(sourcePixels);
-        ref Bgr24 destBaseRef = ref MemoryMarshal.GetReference(destinationPixels);
+        ref TPixel sourceBase = ref MemoryMarshal.GetReference(source);
+        ref Bgr24 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-        for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+        for (nuint i = 0; i < (uint)source.Length; i++)
         {
-            ref TPixel sp = ref Unsafe.Add(ref sourceBaseRef, i);
-            ref Bgr24 dp = ref Unsafe.Add(ref destBaseRef, i);
-
-            dp.FromScaledVector4(sp.ToScaledVector4());
+            Unsafe.Add(ref destinationBase, i) = Bgr24.FromScaledVector4(Unsafe.Add(ref sourceBase, i).ToScaledVector4());
         }
     }
 
     /// <summary>
     /// A helper for <see cref="ToBgr24(Configuration, ReadOnlySpan{TPixel}, Span{Bgr24})"/> that expects a byte span as destination.
-    /// The layout of the data in 'destBytes' must be compatible with <see cref="Bgr24"/> layout.
+    /// The layout of the data in 'destination' must be compatible with <see cref="Bgr24"/> layout.
     /// </summary>
     /// <param name="configuration">A <see cref="Configuration"/> to configure internal operations</param>
-    /// <param name="sourcePixels">The <see cref="Span{T}"/> to the source pixels.</param>
-    /// <param name="destBytes">The <see cref="Span{T}"/> to the destination bytes.</param>
+    /// <param name="source">The <see cref="Span{T}"/> to the source pixels.</param>
+    /// <param name="destination">The <see cref="Span{T}"/> to the destination bytes.</param>
     /// <param name="count">The number of pixels to convert.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public void ToBgr24Bytes(Configuration configuration, ReadOnlySpan<TPixel> sourcePixels, Span<byte> destBytes, int count)
+    public void ToBgr24Bytes(Configuration configuration, ReadOnlySpan<TPixel> source, Span<byte> destination, int count)
     {
-        this.ToBgr24(configuration, sourcePixels.Slice(0, count), MemoryMarshal.Cast<byte, Bgr24>(destBytes));
+        this.ToBgr24(configuration, source.Slice(0, count), MemoryMarshal.Cast<byte, Bgr24>(destination));
     }
 
     /// <summary>
@@ -230,20 +212,17 @@ public partial class PixelOperations<TPixel>
     /// </summary>
     /// <param name="configuration">A <see cref="Configuration"/> to configure internal operations.</param>
     /// <param name="source">The source <see cref="Span{T}"/> of <see cref="Bgra32"/> data.</param>
-    /// <param name="destinationPixels">The <see cref="Span{T}"/> to the destination pixels.</param>
-    public virtual void FromBgra32(Configuration configuration, ReadOnlySpan<Bgra32> source, Span<TPixel> destinationPixels)
+    /// <param name="destination">The <see cref="Span{T}"/> to the destination pixels.</param>
+    public virtual void FromBgra32(Configuration configuration, ReadOnlySpan<Bgra32> source, Span<TPixel> destination)
     {
-        Guard.DestinationShouldNotBeTooShort(source, destinationPixels, nameof(destinationPixels));
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-        ref Bgra32 sourceBaseRef = ref MemoryMarshal.GetReference(source);
-        ref TPixel destBaseRef = ref MemoryMarshal.GetReference(destinationPixels);
+        ref Bgra32 sourceBase = ref MemoryMarshal.GetReference(source);
+        ref TPixel destinationBase = ref MemoryMarshal.GetReference(destination);
 
         for (nuint i = 0; i < (uint)source.Length; i++)
         {
-            ref Bgra32 sp = ref Unsafe.Add(ref sourceBaseRef, i);
-            ref TPixel dp = ref Unsafe.Add(ref destBaseRef, i);
-
-            dp.FromBgra32(sp);
+            Unsafe.Add(ref destinationBase, i) = TPixel.FromBgra32(Unsafe.Add(ref sourceBase, i));
         }
     }
 
@@ -253,48 +232,45 @@ public partial class PixelOperations<TPixel>
     /// </summary>
     /// <param name="configuration">A <see cref="Configuration"/> to configure internal operations.</param>
     /// <param name="sourceBytes">The <see cref="ReadOnlySpan{T}"/> to the source bytes.</param>
-    /// <param name="destinationPixels">The <see cref="Span{T}"/> to the destination pixels.</param>
+    /// <param name="destination">The <see cref="Span{T}"/> to the destination pixels.</param>
     /// <param name="count">The number of pixels to convert.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public void FromBgra32Bytes(Configuration configuration, ReadOnlySpan<byte> sourceBytes, Span<TPixel> destinationPixels, int count)
+    public void FromBgra32Bytes(Configuration configuration, ReadOnlySpan<byte> sourceBytes, Span<TPixel> destination, int count)
     {
-        this.FromBgra32(configuration, MemoryMarshal.Cast<byte, Bgra32>(sourceBytes).Slice(0, count), destinationPixels);
+        this.FromBgra32(configuration, MemoryMarshal.Cast<byte, Bgra32>(sourceBytes).Slice(0, count), destination);
     }
 
     /// <summary>
-    /// Converts all pixels of the 'sourcePixels` span to a span of <see cref="Bgra32"/>-s.
+    /// Converts all pixels of the 'source` span to a span of <see cref="Bgra32"/>-s.
     /// </summary>
     /// <param name="configuration">A <see cref="Configuration"/> to configure internal operations</param>
-    /// <param name="sourcePixels">The span of source pixels</param>
-    /// <param name="destinationPixels">The destination span of <see cref="Bgra32"/> data.</param>
-    public virtual void ToBgra32(Configuration configuration, ReadOnlySpan<TPixel> sourcePixels, Span<Bgra32> destinationPixels)
+    /// <param name="source">The span of source pixels</param>
+    /// <param name="destination">The destination span of <see cref="Bgra32"/> data.</param>
+    public virtual void ToBgra32(Configuration configuration, ReadOnlySpan<TPixel> source, Span<Bgra32> destination)
     {
-        Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-        ref TPixel sourceBaseRef = ref MemoryMarshal.GetReference(sourcePixels);
-        ref Bgra32 destBaseRef = ref MemoryMarshal.GetReference(destinationPixels);
+        ref TPixel sourceBase = ref MemoryMarshal.GetReference(source);
+        ref Bgra32 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-        for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+        for (nuint i = 0; i < (uint)source.Length; i++)
         {
-            ref TPixel sp = ref Unsafe.Add(ref sourceBaseRef, i);
-            ref Bgra32 dp = ref Unsafe.Add(ref destBaseRef, i);
-
-            dp.FromScaledVector4(sp.ToScaledVector4());
+            Unsafe.Add(ref destinationBase, i) = Bgra32.FromScaledVector4(Unsafe.Add(ref sourceBase, i).ToScaledVector4());
         }
     }
 
     /// <summary>
     /// A helper for <see cref="ToBgra32(Configuration, ReadOnlySpan{TPixel}, Span{Bgra32})"/> that expects a byte span as destination.
-    /// The layout of the data in 'destBytes' must be compatible with <see cref="Bgra32"/> layout.
+    /// The layout of the data in 'destination' must be compatible with <see cref="Bgra32"/> layout.
     /// </summary>
     /// <param name="configuration">A <see cref="Configuration"/> to configure internal operations</param>
-    /// <param name="sourcePixels">The <see cref="Span{T}"/> to the source pixels.</param>
-    /// <param name="destBytes">The <see cref="Span{T}"/> to the destination bytes.</param>
+    /// <param name="source">The <see cref="Span{T}"/> to the source pixels.</param>
+    /// <param name="destination">The <see cref="Span{T}"/> to the destination bytes.</param>
     /// <param name="count">The number of pixels to convert.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public void ToBgra32Bytes(Configuration configuration, ReadOnlySpan<TPixel> sourcePixels, Span<byte> destBytes, int count)
+    public void ToBgra32Bytes(Configuration configuration, ReadOnlySpan<TPixel> source, Span<byte> destination, int count)
     {
-        this.ToBgra32(configuration, sourcePixels.Slice(0, count), MemoryMarshal.Cast<byte, Bgra32>(destBytes));
+        this.ToBgra32(configuration, source.Slice(0, count), MemoryMarshal.Cast<byte, Bgra32>(destination));
     }
 
     /// <summary>
@@ -302,20 +278,17 @@ public partial class PixelOperations<TPixel>
     /// </summary>
     /// <param name="configuration">A <see cref="Configuration"/> to configure internal operations.</param>
     /// <param name="source">The source <see cref="Span{T}"/> of <see cref="L8"/> data.</param>
-    /// <param name="destinationPixels">The <see cref="Span{T}"/> to the destination pixels.</param>
-    public virtual void FromL8(Configuration configuration, ReadOnlySpan<L8> source, Span<TPixel> destinationPixels)
+    /// <param name="destination">The <see cref="Span{T}"/> to the destination pixels.</param>
+    public virtual void FromL8(Configuration configuration, ReadOnlySpan<L8> source, Span<TPixel> destination)
     {
-        Guard.DestinationShouldNotBeTooShort(source, destinationPixels, nameof(destinationPixels));
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-        ref L8 sourceBaseRef = ref MemoryMarshal.GetReference(source);
-        ref TPixel destBaseRef = ref MemoryMarshal.GetReference(destinationPixels);
+        ref L8 sourceBase = ref MemoryMarshal.GetReference(source);
+        ref TPixel destinationBase = ref MemoryMarshal.GetReference(destination);
 
         for (nuint i = 0; i < (uint)source.Length; i++)
         {
-            ref L8 sp = ref Unsafe.Add(ref sourceBaseRef, i);
-            ref TPixel dp = ref Unsafe.Add(ref destBaseRef, i);
-
-            dp.FromL8(sp);
+            Unsafe.Add(ref destinationBase, i) = TPixel.FromL8(Unsafe.Add(ref sourceBase, i));
         }
     }
 
@@ -325,48 +298,45 @@ public partial class PixelOperations<TPixel>
     /// </summary>
     /// <param name="configuration">A <see cref="Configuration"/> to configure internal operations.</param>
     /// <param name="sourceBytes">The <see cref="ReadOnlySpan{T}"/> to the source bytes.</param>
-    /// <param name="destinationPixels">The <see cref="Span{T}"/> to the destination pixels.</param>
+    /// <param name="destination">The <see cref="Span{T}"/> to the destination pixels.</param>
     /// <param name="count">The number of pixels to convert.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public void FromL8Bytes(Configuration configuration, ReadOnlySpan<byte> sourceBytes, Span<TPixel> destinationPixels, int count)
+    public void FromL8Bytes(Configuration configuration, ReadOnlySpan<byte> sourceBytes, Span<TPixel> destination, int count)
     {
-        this.FromL8(configuration, MemoryMarshal.Cast<byte, L8>(sourceBytes).Slice(0, count), destinationPixels);
+        this.FromL8(configuration, MemoryMarshal.Cast<byte, L8>(sourceBytes).Slice(0, count), destination);
     }
 
     /// <summary>
-    /// Converts all pixels of the 'sourcePixels` span to a span of <see cref="L8"/>-s.
+    /// Converts all pixels of the 'source` span to a span of <see cref="L8"/>-s.
     /// </summary>
     /// <param name="configuration">A <see cref="Configuration"/> to configure internal operations</param>
-    /// <param name="sourcePixels">The span of source pixels</param>
-    /// <param name="destinationPixels">The destination span of <see cref="L8"/> data.</param>
-    public virtual void ToL8(Configuration configuration, ReadOnlySpan<TPixel> sourcePixels, Span<L8> destinationPixels)
+    /// <param name="source">The span of source pixels</param>
+    /// <param name="destination">The destination span of <see cref="L8"/> data.</param>
+    public virtual void ToL8(Configuration configuration, ReadOnlySpan<TPixel> source, Span<L8> destination)
     {
-        Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-        ref TPixel sourceBaseRef = ref MemoryMarshal.GetReference(sourcePixels);
-        ref L8 destBaseRef = ref MemoryMarshal.GetReference(destinationPixels);
+        ref TPixel sourceBase = ref MemoryMarshal.GetReference(source);
+        ref L8 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-        for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+        for (nuint i = 0; i < (uint)source.Length; i++)
         {
-            ref TPixel sp = ref Unsafe.Add(ref sourceBaseRef, i);
-            ref L8 dp = ref Unsafe.Add(ref destBaseRef, i);
-
-            dp.FromScaledVector4(sp.ToScaledVector4());
+            Unsafe.Add(ref destinationBase, i) = L8.FromScaledVector4(Unsafe.Add(ref sourceBase, i).ToScaledVector4());
         }
     }
 
     /// <summary>
     /// A helper for <see cref="ToL8(Configuration, ReadOnlySpan{TPixel}, Span{L8})"/> that expects a byte span as destination.
-    /// The layout of the data in 'destBytes' must be compatible with <see cref="L8"/> layout.
+    /// The layout of the data in 'destination' must be compatible with <see cref="L8"/> layout.
     /// </summary>
     /// <param name="configuration">A <see cref="Configuration"/> to configure internal operations</param>
-    /// <param name="sourcePixels">The <see cref="Span{T}"/> to the source pixels.</param>
-    /// <param name="destBytes">The <see cref="Span{T}"/> to the destination bytes.</param>
+    /// <param name="source">The <see cref="Span{T}"/> to the source pixels.</param>
+    /// <param name="destination">The <see cref="Span{T}"/> to the destination bytes.</param>
     /// <param name="count">The number of pixels to convert.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public void ToL8Bytes(Configuration configuration, ReadOnlySpan<TPixel> sourcePixels, Span<byte> destBytes, int count)
+    public void ToL8Bytes(Configuration configuration, ReadOnlySpan<TPixel> source, Span<byte> destination, int count)
     {
-        this.ToL8(configuration, sourcePixels.Slice(0, count), MemoryMarshal.Cast<byte, L8>(destBytes));
+        this.ToL8(configuration, source.Slice(0, count), MemoryMarshal.Cast<byte, L8>(destination));
     }
 
     /// <summary>
@@ -374,20 +344,17 @@ public partial class PixelOperations<TPixel>
     /// </summary>
     /// <param name="configuration">A <see cref="Configuration"/> to configure internal operations.</param>
     /// <param name="source">The source <see cref="Span{T}"/> of <see cref="L16"/> data.</param>
-    /// <param name="destinationPixels">The <see cref="Span{T}"/> to the destination pixels.</param>
-    public virtual void FromL16(Configuration configuration, ReadOnlySpan<L16> source, Span<TPixel> destinationPixels)
+    /// <param name="destination">The <see cref="Span{T}"/> to the destination pixels.</param>
+    public virtual void FromL16(Configuration configuration, ReadOnlySpan<L16> source, Span<TPixel> destination)
     {
-        Guard.DestinationShouldNotBeTooShort(source, destinationPixels, nameof(destinationPixels));
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-        ref L16 sourceBaseRef = ref MemoryMarshal.GetReference(source);
-        ref TPixel destBaseRef = ref MemoryMarshal.GetReference(destinationPixels);
+        ref L16 sourceBase = ref MemoryMarshal.GetReference(source);
+        ref TPixel destinationBase = ref MemoryMarshal.GetReference(destination);
 
         for (nuint i = 0; i < (uint)source.Length; i++)
         {
-            ref L16 sp = ref Unsafe.Add(ref sourceBaseRef, i);
-            ref TPixel dp = ref Unsafe.Add(ref destBaseRef, i);
-
-            dp.FromL16(sp);
+            Unsafe.Add(ref destinationBase, i) = TPixel.FromL16(Unsafe.Add(ref sourceBase, i));
         }
     }
 
@@ -397,48 +364,45 @@ public partial class PixelOperations<TPixel>
     /// </summary>
     /// <param name="configuration">A <see cref="Configuration"/> to configure internal operations.</param>
     /// <param name="sourceBytes">The <see cref="ReadOnlySpan{T}"/> to the source bytes.</param>
-    /// <param name="destinationPixels">The <see cref="Span{T}"/> to the destination pixels.</param>
+    /// <param name="destination">The <see cref="Span{T}"/> to the destination pixels.</param>
     /// <param name="count">The number of pixels to convert.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public void FromL16Bytes(Configuration configuration, ReadOnlySpan<byte> sourceBytes, Span<TPixel> destinationPixels, int count)
+    public void FromL16Bytes(Configuration configuration, ReadOnlySpan<byte> sourceBytes, Span<TPixel> destination, int count)
     {
-        this.FromL16(configuration, MemoryMarshal.Cast<byte, L16>(sourceBytes).Slice(0, count), destinationPixels);
+        this.FromL16(configuration, MemoryMarshal.Cast<byte, L16>(sourceBytes).Slice(0, count), destination);
     }
 
     /// <summary>
-    /// Converts all pixels of the 'sourcePixels` span to a span of <see cref="L16"/>-s.
+    /// Converts all pixels of the 'source` span to a span of <see cref="L16"/>-s.
     /// </summary>
     /// <param name="configuration">A <see cref="Configuration"/> to configure internal operations</param>
-    /// <param name="sourcePixels">The span of source pixels</param>
-    /// <param name="destinationPixels">The destination span of <see cref="L16"/> data.</param>
-    public virtual void ToL16(Configuration configuration, ReadOnlySpan<TPixel> sourcePixels, Span<L16> destinationPixels)
+    /// <param name="source">The span of source pixels</param>
+    /// <param name="destination">The destination span of <see cref="L16"/> data.</param>
+    public virtual void ToL16(Configuration configuration, ReadOnlySpan<TPixel> source, Span<L16> destination)
     {
-        Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-        ref TPixel sourceBaseRef = ref MemoryMarshal.GetReference(sourcePixels);
-        ref L16 destBaseRef = ref MemoryMarshal.GetReference(destinationPixels);
+        ref TPixel sourceBase = ref MemoryMarshal.GetReference(source);
+        ref L16 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-        for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+        for (nuint i = 0; i < (uint)source.Length; i++)
         {
-            ref TPixel sp = ref Unsafe.Add(ref sourceBaseRef, i);
-            ref L16 dp = ref Unsafe.Add(ref destBaseRef, i);
-
-            dp.FromScaledVector4(sp.ToScaledVector4());
+            Unsafe.Add(ref destinationBase, i) = L16.FromScaledVector4(Unsafe.Add(ref sourceBase, i).ToScaledVector4());
         }
     }
 
     /// <summary>
     /// A helper for <see cref="ToL16(Configuration, ReadOnlySpan{TPixel}, Span{L16})"/> that expects a byte span as destination.
-    /// The layout of the data in 'destBytes' must be compatible with <see cref="L16"/> layout.
+    /// The layout of the data in 'destination' must be compatible with <see cref="L16"/> layout.
     /// </summary>
     /// <param name="configuration">A <see cref="Configuration"/> to configure internal operations</param>
-    /// <param name="sourcePixels">The <see cref="Span{T}"/> to the source pixels.</param>
-    /// <param name="destBytes">The <see cref="Span{T}"/> to the destination bytes.</param>
+    /// <param name="source">The <see cref="Span{T}"/> to the source pixels.</param>
+    /// <param name="destination">The <see cref="Span{T}"/> to the destination bytes.</param>
     /// <param name="count">The number of pixels to convert.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public void ToL16Bytes(Configuration configuration, ReadOnlySpan<TPixel> sourcePixels, Span<byte> destBytes, int count)
+    public void ToL16Bytes(Configuration configuration, ReadOnlySpan<TPixel> source, Span<byte> destination, int count)
     {
-        this.ToL16(configuration, sourcePixels.Slice(0, count), MemoryMarshal.Cast<byte, L16>(destBytes));
+        this.ToL16(configuration, source.Slice(0, count), MemoryMarshal.Cast<byte, L16>(destination));
     }
 
     /// <summary>
@@ -446,20 +410,17 @@ public partial class PixelOperations<TPixel>
     /// </summary>
     /// <param name="configuration">A <see cref="Configuration"/> to configure internal operations.</param>
     /// <param name="source">The source <see cref="Span{T}"/> of <see cref="La16"/> data.</param>
-    /// <param name="destinationPixels">The <see cref="Span{T}"/> to the destination pixels.</param>
-    public virtual void FromLa16(Configuration configuration, ReadOnlySpan<La16> source, Span<TPixel> destinationPixels)
+    /// <param name="destination">The <see cref="Span{T}"/> to the destination pixels.</param>
+    public virtual void FromLa16(Configuration configuration, ReadOnlySpan<La16> source, Span<TPixel> destination)
     {
-        Guard.DestinationShouldNotBeTooShort(source, destinationPixels, nameof(destinationPixels));
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-        ref La16 sourceBaseRef = ref MemoryMarshal.GetReference(source);
-        ref TPixel destBaseRef = ref MemoryMarshal.GetReference(destinationPixels);
+        ref La16 sourceBase = ref MemoryMarshal.GetReference(source);
+        ref TPixel destinationBase = ref MemoryMarshal.GetReference(destination);
 
         for (nuint i = 0; i < (uint)source.Length; i++)
         {
-            ref La16 sp = ref Unsafe.Add(ref sourceBaseRef, i);
-            ref TPixel dp = ref Unsafe.Add(ref destBaseRef, i);
-
-            dp.FromLa16(sp);
+            Unsafe.Add(ref destinationBase, i) = TPixel.FromLa16(Unsafe.Add(ref sourceBase, i));
         }
     }
 
@@ -469,48 +430,45 @@ public partial class PixelOperations<TPixel>
     /// </summary>
     /// <param name="configuration">A <see cref="Configuration"/> to configure internal operations.</param>
     /// <param name="sourceBytes">The <see cref="ReadOnlySpan{T}"/> to the source bytes.</param>
-    /// <param name="destinationPixels">The <see cref="Span{T}"/> to the destination pixels.</param>
+    /// <param name="destination">The <see cref="Span{T}"/> to the destination pixels.</param>
     /// <param name="count">The number of pixels to convert.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public void FromLa16Bytes(Configuration configuration, ReadOnlySpan<byte> sourceBytes, Span<TPixel> destinationPixels, int count)
+    public void FromLa16Bytes(Configuration configuration, ReadOnlySpan<byte> sourceBytes, Span<TPixel> destination, int count)
     {
-        this.FromLa16(configuration, MemoryMarshal.Cast<byte, La16>(sourceBytes).Slice(0, count), destinationPixels);
+        this.FromLa16(configuration, MemoryMarshal.Cast<byte, La16>(sourceBytes).Slice(0, count), destination);
     }
 
     /// <summary>
-    /// Converts all pixels of the 'sourcePixels` span to a span of <see cref="La16"/>-s.
+    /// Converts all pixels of the 'source` span to a span of <see cref="La16"/>-s.
     /// </summary>
     /// <param name="configuration">A <see cref="Configuration"/> to configure internal operations</param>
-    /// <param name="sourcePixels">The span of source pixels</param>
-    /// <param name="destinationPixels">The destination span of <see cref="La16"/> data.</param>
-    public virtual void ToLa16(Configuration configuration, ReadOnlySpan<TPixel> sourcePixels, Span<La16> destinationPixels)
+    /// <param name="source">The span of source pixels</param>
+    /// <param name="destination">The destination span of <see cref="La16"/> data.</param>
+    public virtual void ToLa16(Configuration configuration, ReadOnlySpan<TPixel> source, Span<La16> destination)
     {
-        Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-        ref TPixel sourceBaseRef = ref MemoryMarshal.GetReference(sourcePixels);
-        ref La16 destBaseRef = ref MemoryMarshal.GetReference(destinationPixels);
+        ref TPixel sourceBase = ref MemoryMarshal.GetReference(source);
+        ref La16 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-        for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+        for (nuint i = 0; i < (uint)source.Length; i++)
         {
-            ref TPixel sp = ref Unsafe.Add(ref sourceBaseRef, i);
-            ref La16 dp = ref Unsafe.Add(ref destBaseRef, i);
-
-            dp.FromScaledVector4(sp.ToScaledVector4());
+            Unsafe.Add(ref destinationBase, i) = La16.FromScaledVector4(Unsafe.Add(ref sourceBase, i).ToScaledVector4());
         }
     }
 
     /// <summary>
     /// A helper for <see cref="ToLa16(Configuration, ReadOnlySpan{TPixel}, Span{La16})"/> that expects a byte span as destination.
-    /// The layout of the data in 'destBytes' must be compatible with <see cref="La16"/> layout.
+    /// The layout of the data in 'destination' must be compatible with <see cref="La16"/> layout.
     /// </summary>
     /// <param name="configuration">A <see cref="Configuration"/> to configure internal operations</param>
-    /// <param name="sourcePixels">The <see cref="Span{T}"/> to the source pixels.</param>
-    /// <param name="destBytes">The <see cref="Span{T}"/> to the destination bytes.</param>
+    /// <param name="source">The <see cref="Span{T}"/> to the source pixels.</param>
+    /// <param name="destination">The <see cref="Span{T}"/> to the destination bytes.</param>
     /// <param name="count">The number of pixels to convert.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public void ToLa16Bytes(Configuration configuration, ReadOnlySpan<TPixel> sourcePixels, Span<byte> destBytes, int count)
+    public void ToLa16Bytes(Configuration configuration, ReadOnlySpan<TPixel> source, Span<byte> destination, int count)
     {
-        this.ToLa16(configuration, sourcePixels.Slice(0, count), MemoryMarshal.Cast<byte, La16>(destBytes));
+        this.ToLa16(configuration, source.Slice(0, count), MemoryMarshal.Cast<byte, La16>(destination));
     }
 
     /// <summary>
@@ -518,20 +476,17 @@ public partial class PixelOperations<TPixel>
     /// </summary>
     /// <param name="configuration">A <see cref="Configuration"/> to configure internal operations.</param>
     /// <param name="source">The source <see cref="Span{T}"/> of <see cref="La32"/> data.</param>
-    /// <param name="destinationPixels">The <see cref="Span{T}"/> to the destination pixels.</param>
-    public virtual void FromLa32(Configuration configuration, ReadOnlySpan<La32> source, Span<TPixel> destinationPixels)
+    /// <param name="destination">The <see cref="Span{T}"/> to the destination pixels.</param>
+    public virtual void FromLa32(Configuration configuration, ReadOnlySpan<La32> source, Span<TPixel> destination)
     {
-        Guard.DestinationShouldNotBeTooShort(source, destinationPixels, nameof(destinationPixels));
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-        ref La32 sourceBaseRef = ref MemoryMarshal.GetReference(source);
-        ref TPixel destBaseRef = ref MemoryMarshal.GetReference(destinationPixels);
+        ref La32 sourceBase = ref MemoryMarshal.GetReference(source);
+        ref TPixel destinationBase = ref MemoryMarshal.GetReference(destination);
 
         for (nuint i = 0; i < (uint)source.Length; i++)
         {
-            ref La32 sp = ref Unsafe.Add(ref sourceBaseRef, i);
-            ref TPixel dp = ref Unsafe.Add(ref destBaseRef, i);
-
-            dp.FromLa32(sp);
+            Unsafe.Add(ref destinationBase, i) = TPixel.FromLa32(Unsafe.Add(ref sourceBase, i));
         }
     }
 
@@ -541,48 +496,45 @@ public partial class PixelOperations<TPixel>
     /// </summary>
     /// <param name="configuration">A <see cref="Configuration"/> to configure internal operations.</param>
     /// <param name="sourceBytes">The <see cref="ReadOnlySpan{T}"/> to the source bytes.</param>
-    /// <param name="destinationPixels">The <see cref="Span{T}"/> to the destination pixels.</param>
+    /// <param name="destination">The <see cref="Span{T}"/> to the destination pixels.</param>
     /// <param name="count">The number of pixels to convert.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public void FromLa32Bytes(Configuration configuration, ReadOnlySpan<byte> sourceBytes, Span<TPixel> destinationPixels, int count)
+    public void FromLa32Bytes(Configuration configuration, ReadOnlySpan<byte> sourceBytes, Span<TPixel> destination, int count)
     {
-        this.FromLa32(configuration, MemoryMarshal.Cast<byte, La32>(sourceBytes).Slice(0, count), destinationPixels);
+        this.FromLa32(configuration, MemoryMarshal.Cast<byte, La32>(sourceBytes).Slice(0, count), destination);
     }
 
     /// <summary>
-    /// Converts all pixels of the 'sourcePixels` span to a span of <see cref="La32"/>-s.
+    /// Converts all pixels of the 'source` span to a span of <see cref="La32"/>-s.
     /// </summary>
     /// <param name="configuration">A <see cref="Configuration"/> to configure internal operations</param>
-    /// <param name="sourcePixels">The span of source pixels</param>
-    /// <param name="destinationPixels">The destination span of <see cref="La32"/> data.</param>
-    public virtual void ToLa32(Configuration configuration, ReadOnlySpan<TPixel> sourcePixels, Span<La32> destinationPixels)
+    /// <param name="source">The span of source pixels</param>
+    /// <param name="destination">The destination span of <see cref="La32"/> data.</param>
+    public virtual void ToLa32(Configuration configuration, ReadOnlySpan<TPixel> source, Span<La32> destination)
     {
-        Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-        ref TPixel sourceBaseRef = ref MemoryMarshal.GetReference(sourcePixels);
-        ref La32 destBaseRef = ref MemoryMarshal.GetReference(destinationPixels);
+        ref TPixel sourceBase = ref MemoryMarshal.GetReference(source);
+        ref La32 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-        for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+        for (nuint i = 0; i < (uint)source.Length; i++)
         {
-            ref TPixel sp = ref Unsafe.Add(ref sourceBaseRef, i);
-            ref La32 dp = ref Unsafe.Add(ref destBaseRef, i);
-
-            dp.FromScaledVector4(sp.ToScaledVector4());
+            Unsafe.Add(ref destinationBase, i) = La32.FromScaledVector4(Unsafe.Add(ref sourceBase, i).ToScaledVector4());
         }
     }
 
     /// <summary>
     /// A helper for <see cref="ToLa32(Configuration, ReadOnlySpan{TPixel}, Span{La32})"/> that expects a byte span as destination.
-    /// The layout of the data in 'destBytes' must be compatible with <see cref="La32"/> layout.
+    /// The layout of the data in 'destination' must be compatible with <see cref="La32"/> layout.
     /// </summary>
     /// <param name="configuration">A <see cref="Configuration"/> to configure internal operations</param>
-    /// <param name="sourcePixels">The <see cref="Span{T}"/> to the source pixels.</param>
-    /// <param name="destBytes">The <see cref="Span{T}"/> to the destination bytes.</param>
+    /// <param name="source">The <see cref="Span{T}"/> to the source pixels.</param>
+    /// <param name="destination">The <see cref="Span{T}"/> to the destination bytes.</param>
     /// <param name="count">The number of pixels to convert.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public void ToLa32Bytes(Configuration configuration, ReadOnlySpan<TPixel> sourcePixels, Span<byte> destBytes, int count)
+    public void ToLa32Bytes(Configuration configuration, ReadOnlySpan<TPixel> source, Span<byte> destination, int count)
     {
-        this.ToLa32(configuration, sourcePixels.Slice(0, count), MemoryMarshal.Cast<byte, La32>(destBytes));
+        this.ToLa32(configuration, source.Slice(0, count), MemoryMarshal.Cast<byte, La32>(destination));
     }
 
     /// <summary>
@@ -590,20 +542,17 @@ public partial class PixelOperations<TPixel>
     /// </summary>
     /// <param name="configuration">A <see cref="Configuration"/> to configure internal operations.</param>
     /// <param name="source">The source <see cref="Span{T}"/> of <see cref="Rgb24"/> data.</param>
-    /// <param name="destinationPixels">The <see cref="Span{T}"/> to the destination pixels.</param>
-    public virtual void FromRgb24(Configuration configuration, ReadOnlySpan<Rgb24> source, Span<TPixel> destinationPixels)
+    /// <param name="destination">The <see cref="Span{T}"/> to the destination pixels.</param>
+    public virtual void FromRgb24(Configuration configuration, ReadOnlySpan<Rgb24> source, Span<TPixel> destination)
     {
-        Guard.DestinationShouldNotBeTooShort(source, destinationPixels, nameof(destinationPixels));
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-        ref Rgb24 sourceBaseRef = ref MemoryMarshal.GetReference(source);
-        ref TPixel destBaseRef = ref MemoryMarshal.GetReference(destinationPixels);
+        ref Rgb24 sourceBase = ref MemoryMarshal.GetReference(source);
+        ref TPixel destinationBase = ref MemoryMarshal.GetReference(destination);
 
         for (nuint i = 0; i < (uint)source.Length; i++)
         {
-            ref Rgb24 sp = ref Unsafe.Add(ref sourceBaseRef, i);
-            ref TPixel dp = ref Unsafe.Add(ref destBaseRef, i);
-
-            dp.FromRgb24(sp);
+            Unsafe.Add(ref destinationBase, i) = TPixel.FromRgb24(Unsafe.Add(ref sourceBase, i));
         }
     }
 
@@ -613,48 +562,45 @@ public partial class PixelOperations<TPixel>
     /// </summary>
     /// <param name="configuration">A <see cref="Configuration"/> to configure internal operations.</param>
     /// <param name="sourceBytes">The <see cref="ReadOnlySpan{T}"/> to the source bytes.</param>
-    /// <param name="destinationPixels">The <see cref="Span{T}"/> to the destination pixels.</param>
+    /// <param name="destination">The <see cref="Span{T}"/> to the destination pixels.</param>
     /// <param name="count">The number of pixels to convert.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public void FromRgb24Bytes(Configuration configuration, ReadOnlySpan<byte> sourceBytes, Span<TPixel> destinationPixels, int count)
+    public void FromRgb24Bytes(Configuration configuration, ReadOnlySpan<byte> sourceBytes, Span<TPixel> destination, int count)
     {
-        this.FromRgb24(configuration, MemoryMarshal.Cast<byte, Rgb24>(sourceBytes).Slice(0, count), destinationPixels);
+        this.FromRgb24(configuration, MemoryMarshal.Cast<byte, Rgb24>(sourceBytes).Slice(0, count), destination);
     }
 
     /// <summary>
-    /// Converts all pixels of the 'sourcePixels` span to a span of <see cref="Rgb24"/>-s.
+    /// Converts all pixels of the 'source` span to a span of <see cref="Rgb24"/>-s.
     /// </summary>
     /// <param name="configuration">A <see cref="Configuration"/> to configure internal operations</param>
-    /// <param name="sourcePixels">The span of source pixels</param>
-    /// <param name="destinationPixels">The destination span of <see cref="Rgb24"/> data.</param>
-    public virtual void ToRgb24(Configuration configuration, ReadOnlySpan<TPixel> sourcePixels, Span<Rgb24> destinationPixels)
+    /// <param name="source">The span of source pixels</param>
+    /// <param name="destination">The destination span of <see cref="Rgb24"/> data.</param>
+    public virtual void ToRgb24(Configuration configuration, ReadOnlySpan<TPixel> source, Span<Rgb24> destination)
     {
-        Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-        ref TPixel sourceBaseRef = ref MemoryMarshal.GetReference(sourcePixels);
-        ref Rgb24 destBaseRef = ref MemoryMarshal.GetReference(destinationPixels);
+        ref TPixel sourceBase = ref MemoryMarshal.GetReference(source);
+        ref Rgb24 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-        for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+        for (nuint i = 0; i < (uint)source.Length; i++)
         {
-            ref TPixel sp = ref Unsafe.Add(ref sourceBaseRef, i);
-            ref Rgb24 dp = ref Unsafe.Add(ref destBaseRef, i);
-
-            dp.FromScaledVector4(sp.ToScaledVector4());
+            Unsafe.Add(ref destinationBase, i) = Rgb24.FromScaledVector4(Unsafe.Add(ref sourceBase, i).ToScaledVector4());
         }
     }
 
     /// <summary>
     /// A helper for <see cref="ToRgb24(Configuration, ReadOnlySpan{TPixel}, Span{Rgb24})"/> that expects a byte span as destination.
-    /// The layout of the data in 'destBytes' must be compatible with <see cref="Rgb24"/> layout.
+    /// The layout of the data in 'destination' must be compatible with <see cref="Rgb24"/> layout.
     /// </summary>
     /// <param name="configuration">A <see cref="Configuration"/> to configure internal operations</param>
-    /// <param name="sourcePixels">The <see cref="Span{T}"/> to the source pixels.</param>
-    /// <param name="destBytes">The <see cref="Span{T}"/> to the destination bytes.</param>
+    /// <param name="source">The <see cref="Span{T}"/> to the source pixels.</param>
+    /// <param name="destination">The <see cref="Span{T}"/> to the destination bytes.</param>
     /// <param name="count">The number of pixels to convert.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public void ToRgb24Bytes(Configuration configuration, ReadOnlySpan<TPixel> sourcePixels, Span<byte> destBytes, int count)
+    public void ToRgb24Bytes(Configuration configuration, ReadOnlySpan<TPixel> source, Span<byte> destination, int count)
     {
-        this.ToRgb24(configuration, sourcePixels.Slice(0, count), MemoryMarshal.Cast<byte, Rgb24>(destBytes));
+        this.ToRgb24(configuration, source.Slice(0, count), MemoryMarshal.Cast<byte, Rgb24>(destination));
     }
 
     /// <summary>
@@ -662,20 +608,17 @@ public partial class PixelOperations<TPixel>
     /// </summary>
     /// <param name="configuration">A <see cref="Configuration"/> to configure internal operations.</param>
     /// <param name="source">The source <see cref="Span{T}"/> of <see cref="Rgba32"/> data.</param>
-    /// <param name="destinationPixels">The <see cref="Span{T}"/> to the destination pixels.</param>
-    public virtual void FromRgba32(Configuration configuration, ReadOnlySpan<Rgba32> source, Span<TPixel> destinationPixels)
+    /// <param name="destination">The <see cref="Span{T}"/> to the destination pixels.</param>
+    public virtual void FromRgba32(Configuration configuration, ReadOnlySpan<Rgba32> source, Span<TPixel> destination)
     {
-        Guard.DestinationShouldNotBeTooShort(source, destinationPixels, nameof(destinationPixels));
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-        ref Rgba32 sourceBaseRef = ref MemoryMarshal.GetReference(source);
-        ref TPixel destBaseRef = ref MemoryMarshal.GetReference(destinationPixels);
+        ref Rgba32 sourceBase = ref MemoryMarshal.GetReference(source);
+        ref TPixel destinationBase = ref MemoryMarshal.GetReference(destination);
 
         for (nuint i = 0; i < (uint)source.Length; i++)
         {
-            ref Rgba32 sp = ref Unsafe.Add(ref sourceBaseRef, i);
-            ref TPixel dp = ref Unsafe.Add(ref destBaseRef, i);
-
-            dp.FromRgba32(sp);
+            Unsafe.Add(ref destinationBase, i) = TPixel.FromRgba32(Unsafe.Add(ref sourceBase, i));
         }
     }
 
@@ -685,48 +628,45 @@ public partial class PixelOperations<TPixel>
     /// </summary>
     /// <param name="configuration">A <see cref="Configuration"/> to configure internal operations.</param>
     /// <param name="sourceBytes">The <see cref="ReadOnlySpan{T}"/> to the source bytes.</param>
-    /// <param name="destinationPixels">The <see cref="Span{T}"/> to the destination pixels.</param>
+    /// <param name="destination">The <see cref="Span{T}"/> to the destination pixels.</param>
     /// <param name="count">The number of pixels to convert.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public void FromRgba32Bytes(Configuration configuration, ReadOnlySpan<byte> sourceBytes, Span<TPixel> destinationPixels, int count)
+    public void FromRgba32Bytes(Configuration configuration, ReadOnlySpan<byte> sourceBytes, Span<TPixel> destination, int count)
     {
-        this.FromRgba32(configuration, MemoryMarshal.Cast<byte, Rgba32>(sourceBytes).Slice(0, count), destinationPixels);
+        this.FromRgba32(configuration, MemoryMarshal.Cast<byte, Rgba32>(sourceBytes).Slice(0, count), destination);
     }
 
     /// <summary>
-    /// Converts all pixels of the 'sourcePixels` span to a span of <see cref="Rgba32"/>-s.
+    /// Converts all pixels of the 'source` span to a span of <see cref="Rgba32"/>-s.
     /// </summary>
     /// <param name="configuration">A <see cref="Configuration"/> to configure internal operations</param>
-    /// <param name="sourcePixels">The span of source pixels</param>
-    /// <param name="destinationPixels">The destination span of <see cref="Rgba32"/> data.</param>
-    public virtual void ToRgba32(Configuration configuration, ReadOnlySpan<TPixel> sourcePixels, Span<Rgba32> destinationPixels)
+    /// <param name="source">The span of source pixels</param>
+    /// <param name="destination">The destination span of <see cref="Rgba32"/> data.</param>
+    public virtual void ToRgba32(Configuration configuration, ReadOnlySpan<TPixel> source, Span<Rgba32> destination)
     {
-        Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-        ref TPixel sourceBaseRef = ref MemoryMarshal.GetReference(sourcePixels);
-        ref Rgba32 destBaseRef = ref MemoryMarshal.GetReference(destinationPixels);
+        ref TPixel sourceBase = ref MemoryMarshal.GetReference(source);
+        ref Rgba32 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-        for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+        for (nuint i = 0; i < (uint)source.Length; i++)
         {
-            ref TPixel sp = ref Unsafe.Add(ref sourceBaseRef, i);
-            ref Rgba32 dp = ref Unsafe.Add(ref destBaseRef, i);
-
-            dp.FromScaledVector4(sp.ToScaledVector4());
+            Unsafe.Add(ref destinationBase, i) = Rgba32.FromScaledVector4(Unsafe.Add(ref sourceBase, i).ToScaledVector4());
         }
     }
 
     /// <summary>
     /// A helper for <see cref="ToRgba32(Configuration, ReadOnlySpan{TPixel}, Span{Rgba32})"/> that expects a byte span as destination.
-    /// The layout of the data in 'destBytes' must be compatible with <see cref="Rgba32"/> layout.
+    /// The layout of the data in 'destination' must be compatible with <see cref="Rgba32"/> layout.
     /// </summary>
     /// <param name="configuration">A <see cref="Configuration"/> to configure internal operations</param>
-    /// <param name="sourcePixels">The <see cref="Span{T}"/> to the source pixels.</param>
-    /// <param name="destBytes">The <see cref="Span{T}"/> to the destination bytes.</param>
+    /// <param name="source">The <see cref="Span{T}"/> to the source pixels.</param>
+    /// <param name="destination">The <see cref="Span{T}"/> to the destination bytes.</param>
     /// <param name="count">The number of pixels to convert.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public void ToRgba32Bytes(Configuration configuration, ReadOnlySpan<TPixel> sourcePixels, Span<byte> destBytes, int count)
+    public void ToRgba32Bytes(Configuration configuration, ReadOnlySpan<TPixel> source, Span<byte> destination, int count)
     {
-        this.ToRgba32(configuration, sourcePixels.Slice(0, count), MemoryMarshal.Cast<byte, Rgba32>(destBytes));
+        this.ToRgba32(configuration, source.Slice(0, count), MemoryMarshal.Cast<byte, Rgba32>(destination));
     }
 
     /// <summary>
@@ -734,20 +674,17 @@ public partial class PixelOperations<TPixel>
     /// </summary>
     /// <param name="configuration">A <see cref="Configuration"/> to configure internal operations.</param>
     /// <param name="source">The source <see cref="Span{T}"/> of <see cref="Rgb48"/> data.</param>
-    /// <param name="destinationPixels">The <see cref="Span{T}"/> to the destination pixels.</param>
-    public virtual void FromRgb48(Configuration configuration, ReadOnlySpan<Rgb48> source, Span<TPixel> destinationPixels)
+    /// <param name="destination">The <see cref="Span{T}"/> to the destination pixels.</param>
+    public virtual void FromRgb48(Configuration configuration, ReadOnlySpan<Rgb48> source, Span<TPixel> destination)
     {
-        Guard.DestinationShouldNotBeTooShort(source, destinationPixels, nameof(destinationPixels));
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-        ref Rgb48 sourceBaseRef = ref MemoryMarshal.GetReference(source);
-        ref TPixel destBaseRef = ref MemoryMarshal.GetReference(destinationPixels);
+        ref Rgb48 sourceBase = ref MemoryMarshal.GetReference(source);
+        ref TPixel destinationBase = ref MemoryMarshal.GetReference(destination);
 
         for (nuint i = 0; i < (uint)source.Length; i++)
         {
-            ref Rgb48 sp = ref Unsafe.Add(ref sourceBaseRef, i);
-            ref TPixel dp = ref Unsafe.Add(ref destBaseRef, i);
-
-            dp.FromRgb48(sp);
+            Unsafe.Add(ref destinationBase, i) = TPixel.FromRgb48(Unsafe.Add(ref sourceBase, i));
         }
     }
 
@@ -757,48 +694,45 @@ public partial class PixelOperations<TPixel>
     /// </summary>
     /// <param name="configuration">A <see cref="Configuration"/> to configure internal operations.</param>
     /// <param name="sourceBytes">The <see cref="ReadOnlySpan{T}"/> to the source bytes.</param>
-    /// <param name="destinationPixels">The <see cref="Span{T}"/> to the destination pixels.</param>
+    /// <param name="destination">The <see cref="Span{T}"/> to the destination pixels.</param>
     /// <param name="count">The number of pixels to convert.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public void FromRgb48Bytes(Configuration configuration, ReadOnlySpan<byte> sourceBytes, Span<TPixel> destinationPixels, int count)
+    public void FromRgb48Bytes(Configuration configuration, ReadOnlySpan<byte> sourceBytes, Span<TPixel> destination, int count)
     {
-        this.FromRgb48(configuration, MemoryMarshal.Cast<byte, Rgb48>(sourceBytes).Slice(0, count), destinationPixels);
+        this.FromRgb48(configuration, MemoryMarshal.Cast<byte, Rgb48>(sourceBytes).Slice(0, count), destination);
     }
 
     /// <summary>
-    /// Converts all pixels of the 'sourcePixels` span to a span of <see cref="Rgb48"/>-s.
+    /// Converts all pixels of the 'source` span to a span of <see cref="Rgb48"/>-s.
     /// </summary>
     /// <param name="configuration">A <see cref="Configuration"/> to configure internal operations</param>
-    /// <param name="sourcePixels">The span of source pixels</param>
-    /// <param name="destinationPixels">The destination span of <see cref="Rgb48"/> data.</param>
-    public virtual void ToRgb48(Configuration configuration, ReadOnlySpan<TPixel> sourcePixels, Span<Rgb48> destinationPixels)
+    /// <param name="source">The span of source pixels</param>
+    /// <param name="destination">The destination span of <see cref="Rgb48"/> data.</param>
+    public virtual void ToRgb48(Configuration configuration, ReadOnlySpan<TPixel> source, Span<Rgb48> destination)
     {
-        Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-        ref TPixel sourceBaseRef = ref MemoryMarshal.GetReference(sourcePixels);
-        ref Rgb48 destBaseRef = ref MemoryMarshal.GetReference(destinationPixels);
+        ref TPixel sourceBase = ref MemoryMarshal.GetReference(source);
+        ref Rgb48 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-        for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+        for (nuint i = 0; i < (uint)source.Length; i++)
         {
-            ref TPixel sp = ref Unsafe.Add(ref sourceBaseRef, i);
-            ref Rgb48 dp = ref Unsafe.Add(ref destBaseRef, i);
-
-            dp.FromScaledVector4(sp.ToScaledVector4());
+            Unsafe.Add(ref destinationBase, i) = Rgb48.FromScaledVector4(Unsafe.Add(ref sourceBase, i).ToScaledVector4());
         }
     }
 
     /// <summary>
     /// A helper for <see cref="ToRgb48(Configuration, ReadOnlySpan{TPixel}, Span{Rgb48})"/> that expects a byte span as destination.
-    /// The layout of the data in 'destBytes' must be compatible with <see cref="Rgb48"/> layout.
+    /// The layout of the data in 'destination' must be compatible with <see cref="Rgb48"/> layout.
     /// </summary>
     /// <param name="configuration">A <see cref="Configuration"/> to configure internal operations</param>
-    /// <param name="sourcePixels">The <see cref="Span{T}"/> to the source pixels.</param>
-    /// <param name="destBytes">The <see cref="Span{T}"/> to the destination bytes.</param>
+    /// <param name="source">The <see cref="Span{T}"/> to the source pixels.</param>
+    /// <param name="destination">The <see cref="Span{T}"/> to the destination bytes.</param>
     /// <param name="count">The number of pixels to convert.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public void ToRgb48Bytes(Configuration configuration, ReadOnlySpan<TPixel> sourcePixels, Span<byte> destBytes, int count)
+    public void ToRgb48Bytes(Configuration configuration, ReadOnlySpan<TPixel> source, Span<byte> destination, int count)
     {
-        this.ToRgb48(configuration, sourcePixels.Slice(0, count), MemoryMarshal.Cast<byte, Rgb48>(destBytes));
+        this.ToRgb48(configuration, source.Slice(0, count), MemoryMarshal.Cast<byte, Rgb48>(destination));
     }
 
     /// <summary>
@@ -806,20 +740,17 @@ public partial class PixelOperations<TPixel>
     /// </summary>
     /// <param name="configuration">A <see cref="Configuration"/> to configure internal operations.</param>
     /// <param name="source">The source <see cref="Span{T}"/> of <see cref="Rgba64"/> data.</param>
-    /// <param name="destinationPixels">The <see cref="Span{T}"/> to the destination pixels.</param>
-    public virtual void FromRgba64(Configuration configuration, ReadOnlySpan<Rgba64> source, Span<TPixel> destinationPixels)
+    /// <param name="destination">The <see cref="Span{T}"/> to the destination pixels.</param>
+    public virtual void FromRgba64(Configuration configuration, ReadOnlySpan<Rgba64> source, Span<TPixel> destination)
     {
-        Guard.DestinationShouldNotBeTooShort(source, destinationPixels, nameof(destinationPixels));
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-        ref Rgba64 sourceBaseRef = ref MemoryMarshal.GetReference(source);
-        ref TPixel destBaseRef = ref MemoryMarshal.GetReference(destinationPixels);
+        ref Rgba64 sourceBase = ref MemoryMarshal.GetReference(source);
+        ref TPixel destinationBase = ref MemoryMarshal.GetReference(destination);
 
         for (nuint i = 0; i < (uint)source.Length; i++)
         {
-            ref Rgba64 sp = ref Unsafe.Add(ref sourceBaseRef, i);
-            ref TPixel dp = ref Unsafe.Add(ref destBaseRef, i);
-
-            dp.FromRgba64(sp);
+            Unsafe.Add(ref destinationBase, i) = TPixel.FromRgba64(Unsafe.Add(ref sourceBase, i));
         }
     }
 
@@ -829,48 +760,45 @@ public partial class PixelOperations<TPixel>
     /// </summary>
     /// <param name="configuration">A <see cref="Configuration"/> to configure internal operations.</param>
     /// <param name="sourceBytes">The <see cref="ReadOnlySpan{T}"/> to the source bytes.</param>
-    /// <param name="destinationPixels">The <see cref="Span{T}"/> to the destination pixels.</param>
+    /// <param name="destination">The <see cref="Span{T}"/> to the destination pixels.</param>
     /// <param name="count">The number of pixels to convert.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public void FromRgba64Bytes(Configuration configuration, ReadOnlySpan<byte> sourceBytes, Span<TPixel> destinationPixels, int count)
+    public void FromRgba64Bytes(Configuration configuration, ReadOnlySpan<byte> sourceBytes, Span<TPixel> destination, int count)
     {
-        this.FromRgba64(configuration, MemoryMarshal.Cast<byte, Rgba64>(sourceBytes).Slice(0, count), destinationPixels);
+        this.FromRgba64(configuration, MemoryMarshal.Cast<byte, Rgba64>(sourceBytes).Slice(0, count), destination);
     }
 
     /// <summary>
-    /// Converts all pixels of the 'sourcePixels` span to a span of <see cref="Rgba64"/>-s.
+    /// Converts all pixels of the 'source` span to a span of <see cref="Rgba64"/>-s.
     /// </summary>
     /// <param name="configuration">A <see cref="Configuration"/> to configure internal operations</param>
-    /// <param name="sourcePixels">The span of source pixels</param>
-    /// <param name="destinationPixels">The destination span of <see cref="Rgba64"/> data.</param>
-    public virtual void ToRgba64(Configuration configuration, ReadOnlySpan<TPixel> sourcePixels, Span<Rgba64> destinationPixels)
+    /// <param name="source">The span of source pixels</param>
+    /// <param name="destination">The destination span of <see cref="Rgba64"/> data.</param>
+    public virtual void ToRgba64(Configuration configuration, ReadOnlySpan<TPixel> source, Span<Rgba64> destination)
     {
-        Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-        ref TPixel sourceBaseRef = ref MemoryMarshal.GetReference(sourcePixels);
-        ref Rgba64 destBaseRef = ref MemoryMarshal.GetReference(destinationPixels);
+        ref TPixel sourceBase = ref MemoryMarshal.GetReference(source);
+        ref Rgba64 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-        for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+        for (nuint i = 0; i < (uint)source.Length; i++)
         {
-            ref TPixel sp = ref Unsafe.Add(ref sourceBaseRef, i);
-            ref Rgba64 dp = ref Unsafe.Add(ref destBaseRef, i);
-
-            dp.FromScaledVector4(sp.ToScaledVector4());
+            Unsafe.Add(ref destinationBase, i) = Rgba64.FromScaledVector4(Unsafe.Add(ref sourceBase, i).ToScaledVector4());
         }
     }
 
     /// <summary>
     /// A helper for <see cref="ToRgba64(Configuration, ReadOnlySpan{TPixel}, Span{Rgba64})"/> that expects a byte span as destination.
-    /// The layout of the data in 'destBytes' must be compatible with <see cref="Rgba64"/> layout.
+    /// The layout of the data in 'destination' must be compatible with <see cref="Rgba64"/> layout.
     /// </summary>
     /// <param name="configuration">A <see cref="Configuration"/> to configure internal operations</param>
-    /// <param name="sourcePixels">The <see cref="Span{T}"/> to the source pixels.</param>
-    /// <param name="destBytes">The <see cref="Span{T}"/> to the destination bytes.</param>
+    /// <param name="source">The <see cref="Span{T}"/> to the source pixels.</param>
+    /// <param name="destination">The <see cref="Span{T}"/> to the destination bytes.</param>
     /// <param name="count">The number of pixels to convert.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public void ToRgba64Bytes(Configuration configuration, ReadOnlySpan<TPixel> sourcePixels, Span<byte> destBytes, int count)
+    public void ToRgba64Bytes(Configuration configuration, ReadOnlySpan<TPixel> source, Span<byte> destination, int count)
     {
-        this.ToRgba64(configuration, sourcePixels.Slice(0, count), MemoryMarshal.Cast<byte, Rgba64>(destBytes));
+        this.ToRgba64(configuration, source.Slice(0, count), MemoryMarshal.Cast<byte, Rgba64>(destination));
     }
 
     /// <summary>
@@ -878,20 +806,17 @@ public partial class PixelOperations<TPixel>
     /// </summary>
     /// <param name="configuration">A <see cref="Configuration"/> to configure internal operations.</param>
     /// <param name="source">The source <see cref="Span{T}"/> of <see cref="Bgra5551"/> data.</param>
-    /// <param name="destinationPixels">The <see cref="Span{T}"/> to the destination pixels.</param>
-    public virtual void FromBgra5551(Configuration configuration, ReadOnlySpan<Bgra5551> source, Span<TPixel> destinationPixels)
+    /// <param name="destination">The <see cref="Span{T}"/> to the destination pixels.</param>
+    public virtual void FromBgra5551(Configuration configuration, ReadOnlySpan<Bgra5551> source, Span<TPixel> destination)
     {
-        Guard.DestinationShouldNotBeTooShort(source, destinationPixels, nameof(destinationPixels));
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-        ref Bgra5551 sourceBaseRef = ref MemoryMarshal.GetReference(source);
-        ref TPixel destBaseRef = ref MemoryMarshal.GetReference(destinationPixels);
+        ref Bgra5551 sourceBase = ref MemoryMarshal.GetReference(source);
+        ref TPixel destinationBase = ref MemoryMarshal.GetReference(destination);
 
         for (nuint i = 0; i < (uint)source.Length; i++)
         {
-            ref Bgra5551 sp = ref Unsafe.Add(ref sourceBaseRef, i);
-            ref TPixel dp = ref Unsafe.Add(ref destBaseRef, i);
-
-            dp.FromBgra5551(sp);
+            Unsafe.Add(ref destinationBase, i) = TPixel.FromBgra5551(Unsafe.Add(ref sourceBase, i));
         }
     }
 
@@ -901,47 +826,44 @@ public partial class PixelOperations<TPixel>
     /// </summary>
     /// <param name="configuration">A <see cref="Configuration"/> to configure internal operations.</param>
     /// <param name="sourceBytes">The <see cref="ReadOnlySpan{T}"/> to the source bytes.</param>
-    /// <param name="destinationPixels">The <see cref="Span{T}"/> to the destination pixels.</param>
+    /// <param name="destination">The <see cref="Span{T}"/> to the destination pixels.</param>
     /// <param name="count">The number of pixels to convert.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public void FromBgra5551Bytes(Configuration configuration, ReadOnlySpan<byte> sourceBytes, Span<TPixel> destinationPixels, int count)
+    public void FromBgra5551Bytes(Configuration configuration, ReadOnlySpan<byte> sourceBytes, Span<TPixel> destination, int count)
     {
-        this.FromBgra5551(configuration, MemoryMarshal.Cast<byte, Bgra5551>(sourceBytes).Slice(0, count), destinationPixels);
+        this.FromBgra5551(configuration, MemoryMarshal.Cast<byte, Bgra5551>(sourceBytes).Slice(0, count), destination);
     }
 
     /// <summary>
-    /// Converts all pixels of the 'sourcePixels` span to a span of <see cref="Bgra5551"/>-s.
+    /// Converts all pixels of the 'source` span to a span of <see cref="Bgra5551"/>-s.
     /// </summary>
     /// <param name="configuration">A <see cref="Configuration"/> to configure internal operations</param>
-    /// <param name="sourcePixels">The span of source pixels</param>
-    /// <param name="destinationPixels">The destination span of <see cref="Bgra5551"/> data.</param>
-    public virtual void ToBgra5551(Configuration configuration, ReadOnlySpan<TPixel> sourcePixels, Span<Bgra5551> destinationPixels)
+    /// <param name="source">The span of source pixels</param>
+    /// <param name="destination">The destination span of <see cref="Bgra5551"/> data.</param>
+    public virtual void ToBgra5551(Configuration configuration, ReadOnlySpan<TPixel> source, Span<Bgra5551> destination)
     {
-        Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-        ref TPixel sourceBaseRef = ref MemoryMarshal.GetReference(sourcePixels);
-        ref Bgra5551 destBaseRef = ref MemoryMarshal.GetReference(destinationPixels);
+        ref TPixel sourceBase = ref MemoryMarshal.GetReference(source);
+        ref Bgra5551 destinationBase = ref MemoryMarshal.GetReference(destination);
 
-        for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+        for (nuint i = 0; i < (uint)source.Length; i++)
         {
-            ref TPixel sp = ref Unsafe.Add(ref sourceBaseRef, i);
-            ref Bgra5551 dp = ref Unsafe.Add(ref destBaseRef, i);
-
-            dp.FromScaledVector4(sp.ToScaledVector4());
+            Unsafe.Add(ref destinationBase, i) = Bgra5551.FromScaledVector4(Unsafe.Add(ref sourceBase, i).ToScaledVector4());
         }
     }
 
     /// <summary>
     /// A helper for <see cref="ToBgra5551(Configuration, ReadOnlySpan{TPixel}, Span{Bgra5551})"/> that expects a byte span as destination.
-    /// The layout of the data in 'destBytes' must be compatible with <see cref="Bgra5551"/> layout.
+    /// The layout of the data in 'destination' must be compatible with <see cref="Bgra5551"/> layout.
     /// </summary>
     /// <param name="configuration">A <see cref="Configuration"/> to configure internal operations</param>
-    /// <param name="sourcePixels">The <see cref="Span{T}"/> to the source pixels.</param>
-    /// <param name="destBytes">The <see cref="Span{T}"/> to the destination bytes.</param>
+    /// <param name="source">The <see cref="Span{T}"/> to the source pixels.</param>
+    /// <param name="destination">The <see cref="Span{T}"/> to the destination bytes.</param>
     /// <param name="count">The number of pixels to convert.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public void ToBgra5551Bytes(Configuration configuration, ReadOnlySpan<TPixel> sourcePixels, Span<byte> destBytes, int count)
+    public void ToBgra5551Bytes(Configuration configuration, ReadOnlySpan<TPixel> source, Span<byte> destination, int count)
     {
-        this.ToBgra5551(configuration, sourcePixels.Slice(0, count), MemoryMarshal.Cast<byte, Bgra5551>(destBytes));
+        this.ToBgra5551(configuration, source.Slice(0, count), MemoryMarshal.Cast<byte, Bgra5551>(destination));
     }
 }
diff --git a/src/ImageSharp/PixelFormats/PixelOperations{TPixel}.Generated.tt b/src/ImageSharp/PixelFormats/PixelOperations{TPixel}.Generated.tt
index 8ba3398e3..b2697cb4e 100644
--- a/src/ImageSharp/PixelFormats/PixelOperations{TPixel}.Generated.tt
+++ b/src/ImageSharp/PixelFormats/PixelOperations{TPixel}.Generated.tt
@@ -20,20 +20,17 @@
     /// </summary>
     /// <param name="configuration">A <see cref="Configuration"/> to configure internal operations.</param>
     /// <param name="source">The source <see cref="Span{T}"/> of <see cref="<#=pixelType#>"/> data.</param>
-    /// <param name="destinationPixels">The <see cref="Span{T}"/> to the destination pixels.</param>
-    public virtual void From<#=pixelType#>(Configuration configuration, ReadOnlySpan<<#=pixelType#>> source, Span<TPixel> destinationPixels)
+    /// <param name="destination">The <see cref="Span{T}"/> to the destination pixels.</param>
+    public virtual void From<#=pixelType#>(Configuration configuration, ReadOnlySpan<<#=pixelType#>> source, Span<TPixel> destination)
     {
-        Guard.DestinationShouldNotBeTooShort(source, destinationPixels, nameof(destinationPixels));
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-        ref <#=pixelType#> sourceBaseRef = ref MemoryMarshal.GetReference(source);
-        ref TPixel destBaseRef = ref MemoryMarshal.GetReference(destinationPixels);
+        ref <#=pixelType#> sourceBase = ref MemoryMarshal.GetReference(source);
+        ref TPixel destinationBase = ref MemoryMarshal.GetReference(destination);
 
         for (nuint i = 0; i < (uint)source.Length; i++)
         {
-            ref <#=pixelType#> sp = ref Unsafe.Add(ref sourceBaseRef, i);
-            ref TPixel dp = ref Unsafe.Add(ref destBaseRef, i);
-
-            dp.From<#=pixelType#>(sp);
+            Unsafe.Add(ref destinationBase, i) = TPixel.From<#=pixelType#>(Unsafe.Add(ref sourceBase, i));
         }
     }
 
@@ -43,12 +40,12 @@
     /// </summary>
     /// <param name="configuration">A <see cref="Configuration"/> to configure internal operations.</param>
     /// <param name="sourceBytes">The <see cref="ReadOnlySpan{T}"/> to the source bytes.</param>
-    /// <param name="destinationPixels">The <see cref="Span{T}"/> to the destination pixels.</param>
+    /// <param name="destination">The <see cref="Span{T}"/> to the destination pixels.</param>
     /// <param name="count">The number of pixels to convert.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public void From<#=pixelType#>Bytes(Configuration configuration, ReadOnlySpan<byte> sourceBytes, Span<TPixel> destinationPixels, int count)
+    public void From<#=pixelType#>Bytes(Configuration configuration, ReadOnlySpan<byte> sourceBytes, Span<TPixel> destination, int count)
     {
-        this.From<#=pixelType#>(configuration, MemoryMarshal.Cast<byte, <#=pixelType#>>(sourceBytes).Slice(0, count), destinationPixels);
+        this.From<#=pixelType#>(configuration, MemoryMarshal.Cast<byte, <#=pixelType#>>(sourceBytes).Slice(0, count), destination);
     }
 
 <#
@@ -58,39 +55,36 @@
     {
         #>
     /// <summary>
-    /// Converts all pixels of the 'sourcePixels` span to a span of <see cref="<#=pixelType#>"/>-s.
+    /// Converts all pixels of the 'source` span to a span of <see cref="<#=pixelType#>"/>-s.
     /// </summary>
     /// <param name="configuration">A <see cref="Configuration"/> to configure internal operations</param>
-    /// <param name="sourcePixels">The span of source pixels</param>
-    /// <param name="destinationPixels">The destination span of <see cref="<#=pixelType#>"/> data.</param>
-    public virtual void To<#=pixelType#>(Configuration configuration, ReadOnlySpan<TPixel> sourcePixels, Span<<#=pixelType#>> destinationPixels)
+    /// <param name="source">The span of source pixels</param>
+    /// <param name="destination">The destination span of <see cref="<#=pixelType#>"/> data.</param>
+    public virtual void To<#=pixelType#>(Configuration configuration, ReadOnlySpan<TPixel> source, Span<<#=pixelType#>> destination)
     {
-        Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-        ref TPixel sourceBaseRef = ref MemoryMarshal.GetReference(sourcePixels);
-        ref <#=pixelType#> destBaseRef = ref MemoryMarshal.GetReference(destinationPixels);
+        ref TPixel sourceBase = ref MemoryMarshal.GetReference(source);
+        ref <#=pixelType#> destinationBase = ref MemoryMarshal.GetReference(destination);
 
-        for (nuint i = 0; i < (uint)sourcePixels.Length; i++)
+        for (nuint i = 0; i < (uint)source.Length; i++)
         {
-            ref TPixel sp = ref Unsafe.Add(ref sourceBaseRef, i);
-            ref <#=pixelType#> dp = ref Unsafe.Add(ref destBaseRef, i);
-
-            dp.FromScaledVector4(sp.ToScaledVector4());
+            Unsafe.Add(ref destinationBase, i) = <#=pixelType#>.FromScaledVector4(Unsafe.Add(ref sourceBase, i).ToScaledVector4());
         }
     }
 
     /// <summary>
     /// A helper for <see cref="To<#=pixelType#>(Configuration, ReadOnlySpan{TPixel}, Span{<#=pixelType#>})"/> that expects a byte span as destination.
-    /// The layout of the data in 'destBytes' must be compatible with <see cref="<#=pixelType#>"/> layout.
+    /// The layout of the data in 'destination' must be compatible with <see cref="<#=pixelType#>"/> layout.
     /// </summary>
     /// <param name="configuration">A <see cref="Configuration"/> to configure internal operations</param>
-    /// <param name="sourcePixels">The <see cref="Span{T}"/> to the source pixels.</param>
-    /// <param name="destBytes">The <see cref="Span{T}"/> to the destination bytes.</param>
+    /// <param name="source">The <see cref="Span{T}"/> to the source pixels.</param>
+    /// <param name="destination">The <see cref="Span{T}"/> to the destination bytes.</param>
     /// <param name="count">The number of pixels to convert.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public void To<#=pixelType#>Bytes(Configuration configuration, ReadOnlySpan<TPixel> sourcePixels, Span<byte> destBytes, int count)
+    public void To<#=pixelType#>Bytes(Configuration configuration, ReadOnlySpan<TPixel> source, Span<byte> destination, int count)
     {
-        this.To<#=pixelType#>(configuration, sourcePixels.Slice(0, count), MemoryMarshal.Cast<byte, <#=pixelType#>>(destBytes));
+        this.To<#=pixelType#>(configuration, source.Slice(0, count), MemoryMarshal.Cast<byte, <#=pixelType#>>(destination));
     }
 <#
     }
diff --git a/src/ImageSharp/PixelFormats/PixelOperations{TPixel}.cs b/src/ImageSharp/PixelFormats/PixelOperations{TPixel}.cs
index beebec828..c769b389d 100644
--- a/src/ImageSharp/PixelFormats/PixelOperations{TPixel}.cs
+++ b/src/ImageSharp/PixelFormats/PixelOperations{TPixel}.cs
@@ -5,7 +5,6 @@ using System.Buffers;
 using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
-using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.Memory;
 
 namespace SixLabors.ImageSharp.PixelFormats;
@@ -18,8 +17,7 @@ namespace SixLabors.ImageSharp.PixelFormats;
 public partial class PixelOperations<TPixel>
     where TPixel : unmanaged, IPixel<TPixel>
 {
-    private static readonly Lazy<PixelTypeInfo> LazyInfo = new(() => PixelTypeInfo.Create<TPixel>(), true);
-    private static readonly Lazy<PixelOperations<TPixel>> LazyInstance = new(() => default(TPixel).CreatePixelOperations(), true);
+    private static readonly Lazy<PixelOperations<TPixel>> LazyInstance = new(TPixel.CreatePixelOperations, true);
 
     /// <summary>
     /// Gets the global <see cref="PixelOperations{TPixel}"/> instance for the pixel type <typeparamref name="TPixel"/>
@@ -32,10 +30,10 @@ public partial class PixelOperations<TPixel>
     /// Gets the pixel type info for the given <typeparamref name="TPixel"/>.
     /// </summary>
     /// <returns>The <see cref="PixelTypeInfo"/>.</returns>
-    public virtual PixelTypeInfo GetPixelTypeInfo() => LazyInfo.Value;
+    public PixelTypeInfo GetPixelTypeInfo() => TPixel.GetPixelTypeInfo();
 
     /// <summary>
-    /// Bulk version of <see cref="IPixel.FromVector4"/> converting 'sourceVectors.Length' pixels into 'destinationColors'.
+    /// Bulk version of <see cref="IPixel{TPixel}.FromVector4"/> converting 'sourceVectors.Length' pixels into 'destinationColors'.
     /// The method is DESTRUCTIVE altering the contents of <paramref name="sourceVectors"/>.
     /// </summary>
     /// <remarks>
@@ -44,21 +42,21 @@ public partial class PixelOperations<TPixel>
     /// </remarks>
     /// <param name="configuration">A <see cref="Configuration"/> to configure internal operations</param>
     /// <param name="sourceVectors">The <see cref="Span{T}"/> to the source vectors.</param>
-    /// <param name="destinationPixels">The <see cref="Span{T}"/> to the destination colors.</param>
+    /// <param name="destination">The <see cref="Span{T}"/> to the destination colors.</param>
     /// <param name="modifiers">The <see cref="PixelConversionModifiers"/> to apply during the conversion</param>
     public virtual void FromVector4Destructive(
         Configuration configuration,
         Span<Vector4> sourceVectors,
-        Span<TPixel> destinationPixels,
+        Span<TPixel> destination,
         PixelConversionModifiers modifiers)
     {
         Guard.NotNull(configuration, nameof(configuration));
 
-        Utils.Vector4Converters.Default.FromVector4(sourceVectors, destinationPixels, modifiers);
+        Utils.Vector4Converters.Default.FromVector4(sourceVectors, destination, modifiers);
     }
 
     /// <summary>
-    /// Bulk version of <see cref="IPixel.FromVector4"/> converting 'sourceVectors.Length' pixels into 'destinationColors'.
+    /// Bulk version of <see cref="IPixel{TPixel}.FromVector4"/> converting 'sourceVectors.Length' pixels into 'destinationColors'.
     /// The method is DESTRUCTIVE altering the contents of <paramref name="sourceVectors"/>.
     /// </summary>
     /// <remarks>
@@ -67,77 +65,77 @@ public partial class PixelOperations<TPixel>
     /// </remarks>
     /// <param name="configuration">A <see cref="Configuration"/> to configure internal operations</param>
     /// <param name="sourceVectors">The <see cref="Span{T}"/> to the source vectors.</param>
-    /// <param name="destinationPixels">The <see cref="Span{T}"/> to the destination colors.</param>
+    /// <param name="destination">The <see cref="Span{T}"/> to the destination colors.</param>
     public void FromVector4Destructive(
         Configuration configuration,
         Span<Vector4> sourceVectors,
-        Span<TPixel> destinationPixels)
-        => this.FromVector4Destructive(configuration, sourceVectors, destinationPixels, PixelConversionModifiers.None);
+        Span<TPixel> destination)
+        => this.FromVector4Destructive(configuration, sourceVectors, destination, PixelConversionModifiers.None);
 
     /// <summary>
     /// Bulk version of <see cref="IPixel.ToVector4()"/> converting 'sourceColors.Length' pixels into 'destinationVectors'.
     /// </summary>
     /// <param name="configuration">A <see cref="Configuration"/> to configure internal operations</param>
-    /// <param name="sourcePixels">The <see cref="Span{T}"/> to the source colors.</param>
+    /// <param name="source">The <see cref="Span{T}"/> to the source colors.</param>
     /// <param name="destinationVectors">The <see cref="Span{T}"/> to the destination vectors.</param>
     /// <param name="modifiers">The <see cref="PixelConversionModifiers"/> to apply during the conversion</param>
     public virtual void ToVector4(
         Configuration configuration,
-        ReadOnlySpan<TPixel> sourcePixels,
+        ReadOnlySpan<TPixel> source,
         Span<Vector4> destinationVectors,
         PixelConversionModifiers modifiers)
     {
         Guard.NotNull(configuration, nameof(configuration));
 
-        Utils.Vector4Converters.Default.ToVector4(sourcePixels, destinationVectors, modifiers);
+        Utils.Vector4Converters.Default.ToVector4(source, destinationVectors, modifiers);
     }
 
     /// <summary>
     /// Bulk version of <see cref="IPixel.ToVector4()"/> converting 'sourceColors.Length' pixels into 'destinationVectors'.
     /// </summary>
     /// <param name="configuration">A <see cref="Configuration"/> to configure internal operations</param>
-    /// <param name="sourcePixels">The <see cref="Span{T}"/> to the source colors.</param>
+    /// <param name="source">The <see cref="Span{T}"/> to the source colors.</param>
     /// <param name="destinationVectors">The <see cref="Span{T}"/> to the destination vectors.</param>
     public void ToVector4(
         Configuration configuration,
-        ReadOnlySpan<TPixel> sourcePixels,
+        ReadOnlySpan<TPixel> source,
         Span<Vector4> destinationVectors)
-        => this.ToVector4(configuration, sourcePixels, destinationVectors, PixelConversionModifiers.None);
+        => this.ToVector4(configuration, source, destinationVectors, PixelConversionModifiers.None);
 
     /// <summary>
-    /// Bulk operation that copies the <paramref name="sourcePixels"/> to <paramref name="destinationPixels"/> in
+    /// Bulk operation that copies the <paramref name="source"/> to <paramref name="destination"/> in
     /// <typeparamref name="TSourcePixel"/> format.
     /// </summary>
     /// <typeparam name="TSourcePixel">The destination pixel type.</typeparam>
     /// <param name="configuration">A <see cref="Configuration"/> to configure internal operations.</param>
-    /// <param name="sourcePixels">The <see cref="ReadOnlySpan{TSourcePixel}"/> to the source pixels.</param>
-    /// <param name="destinationPixels">The <see cref="Span{TPixel}"/> to the destination pixels.</param>
+    /// <param name="source">The <see cref="ReadOnlySpan{TSourcePixel}"/> to the source pixels.</param>
+    /// <param name="destination">The <see cref="Span{TPixel}"/> to the destination pixels.</param>
     public virtual void From<TSourcePixel>(
         Configuration configuration,
-        ReadOnlySpan<TSourcePixel> sourcePixels,
-        Span<TPixel> destinationPixels)
+        ReadOnlySpan<TSourcePixel> source,
+        Span<TPixel> destination)
         where TSourcePixel : unmanaged, IPixel<TSourcePixel>
     {
         const int sliceLength = 1024;
-        int numberOfSlices = sourcePixels.Length / sliceLength;
+        int numberOfSlices = source.Length / sliceLength;
 
         using IMemoryOwner<Vector4> tempVectors = configuration.MemoryAllocator.Allocate<Vector4>(sliceLength);
         Span<Vector4> vectorSpan = tempVectors.GetSpan();
         for (int i = 0; i < numberOfSlices; i++)
         {
             int start = i * sliceLength;
-            ReadOnlySpan<TSourcePixel> s = sourcePixels.Slice(start, sliceLength);
-            Span<TPixel> d = destinationPixels.Slice(start, sliceLength);
+            ReadOnlySpan<TSourcePixel> s = source.Slice(start, sliceLength);
+            Span<TPixel> d = destination.Slice(start, sliceLength);
             PixelOperations<TSourcePixel>.Instance.ToVector4(configuration, s, vectorSpan, PixelConversionModifiers.Scale);
             this.FromVector4Destructive(configuration, vectorSpan, d, PixelConversionModifiers.Scale);
         }
 
         int endOfCompleteSlices = numberOfSlices * sliceLength;
-        int remainder = sourcePixels.Length - endOfCompleteSlices;
+        int remainder = source.Length - endOfCompleteSlices;
         if (remainder > 0)
         {
-            ReadOnlySpan<TSourcePixel> s = sourcePixels[endOfCompleteSlices..];
-            Span<TPixel> d = destinationPixels[endOfCompleteSlices..];
+            ReadOnlySpan<TSourcePixel> s = source[endOfCompleteSlices..];
+            Span<TPixel> d = destination[endOfCompleteSlices..];
             vectorSpan = vectorSpan[..remainder];
             PixelOperations<TSourcePixel>.Instance.ToVector4(configuration, s, vectorSpan, PixelConversionModifiers.Scale);
             this.FromVector4Destructive(configuration, vectorSpan, d, PixelConversionModifiers.Scale);
@@ -145,23 +143,23 @@ public partial class PixelOperations<TPixel>
     }
 
     /// <summary>
-    /// Bulk operation that copies the <paramref name="sourcePixels"/> to <paramref name="destinationPixels"/> in
+    /// Bulk operation that copies the <paramref name="source"/> to <paramref name="destination"/> in
     /// <typeparamref name="TDestinationPixel"/> format.
     /// </summary>
     /// <typeparam name="TDestinationPixel">The destination pixel type.</typeparam>
     /// <param name="configuration">A <see cref="Configuration"/> to configure internal operations.</param>
-    /// <param name="sourcePixels">The <see cref="ReadOnlySpan{TPixel}"/> to the source pixels.</param>
-    /// <param name="destinationPixels">The <see cref="Span{TDestinationPixel}"/> to the destination pixels.</param>
+    /// <param name="source">The <see cref="ReadOnlySpan{TPixel}"/> to the source pixels.</param>
+    /// <param name="destination">The <see cref="Span{TDestinationPixel}"/> to the destination pixels.</param>
     public virtual void To<TDestinationPixel>(
         Configuration configuration,
-        ReadOnlySpan<TPixel> sourcePixels,
-        Span<TDestinationPixel> destinationPixels)
+        ReadOnlySpan<TPixel> source,
+        Span<TDestinationPixel> destination)
         where TDestinationPixel : unmanaged, IPixel<TDestinationPixel>
     {
         Guard.NotNull(configuration, nameof(configuration));
-        Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationPixels, nameof(destinationPixels));
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-        PixelOperations<TDestinationPixel>.Instance.From(configuration, sourcePixels, destinationPixels);
+        PixelOperations<TDestinationPixel>.Instance.From(configuration, source, destination);
     }
 
     /// <summary>
@@ -192,7 +190,7 @@ public partial class PixelOperations<TPixel>
             rgb24.R = Unsafe.Add(ref r, i);
             rgb24.G = Unsafe.Add(ref g, i);
             rgb24.B = Unsafe.Add(ref b, i);
-            Unsafe.Add(ref d, i).FromRgb24(rgb24);
+            Unsafe.Add(ref d, i) = TPixel.FromRgb24(rgb24);
         }
     }
 
@@ -214,15 +212,13 @@ public partial class PixelOperations<TPixel>
 
         int count = source.Length;
 
-        Rgba32 rgba32 = default;
-
         ref float r = ref MemoryMarshal.GetReference(redChannel);
         ref float g = ref MemoryMarshal.GetReference(greenChannel);
         ref float b = ref MemoryMarshal.GetReference(blueChannel);
         ref TPixel src = ref MemoryMarshal.GetReference(source);
         for (nuint i = 0; i < (uint)count; i++)
         {
-            Unsafe.Add(ref src, i).ToRgba32(ref rgba32);
+            Rgba32 rgba32 = Unsafe.Add(ref src, i).ToRgba32();
             Unsafe.Add(ref r, i) = rgba32.R;
             Unsafe.Add(ref g, i) = rgba32.G;
             Unsafe.Add(ref b, i) = rgba32.B;
diff --git a/src/ImageSharp/PixelFormats/PixelTypeInfo.cs b/src/ImageSharp/PixelFormats/PixelTypeInfo.cs
new file mode 100644
index 000000000..7cd1284f4
--- /dev/null
+++ b/src/ImageSharp/PixelFormats/PixelTypeInfo.cs
@@ -0,0 +1,62 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+
+// TODO: Review this type as it's used to represent 2 different things.
+// 1. The encoded image pixel format.
+// 2. The pixel format of the decoded image.
+// Only the bits per pixel is used by the decoder, we should make it a property of the image metadata.
+namespace SixLabors.ImageSharp.PixelFormats;
+
+/// <summary>
+/// Contains information about the pixels that make up an images visual data.
+/// </summary>
+/// <remarks>
+/// Initializes a new instance of the <see cref="PixelTypeInfo"/> struct.
+/// </remarks>
+/// <param name="bitsPerPixel">Color depth, in number of bits per pixel.</param>
+public readonly struct PixelTypeInfo(int bitsPerPixel)
+{
+    /// <summary>
+    /// Gets color depth, in number of bits per pixel.
+    /// </summary>
+    public int BitsPerPixel { get; init; } = bitsPerPixel;
+
+    /// <summary>
+    /// Gets the component bit depth and padding within the pixel.
+    /// </summary>
+    public PixelComponentInfo? ComponentInfo { get; init; }
+
+    /// <summary>
+    /// Gets the pixel color type.
+    /// </summary>
+    public PixelColorType? ColorType { get; init; }
+
+    /// <summary>
+    /// Gets the pixel alpha transparency behavior.
+    /// <see langword="null"/> means unknown, unspecified.
+    /// </summary>
+    public PixelAlphaRepresentation? AlphaRepresentation { get; init; }
+
+    /// <summary>
+    /// Creates a new <see cref="PixelTypeInfo"/> instance.
+    /// </summary>
+    /// <typeparam name="TPixel">The type of pixel format.</typeparam>
+    /// <param name="info">The pixel component info.</param>
+    /// <param name="colorType">The pixel color type.</param>
+    /// <param name="alphaRepresentation">The pixel alpha representation.</param>
+    /// <returns>The <see cref="PixelComponentInfo"/>.</returns>
+    public static PixelTypeInfo Create<TPixel>(
+        PixelComponentInfo info,
+        PixelColorType colorType,
+        PixelAlphaRepresentation alphaRepresentation)
+        where TPixel : unmanaged, IPixel<TPixel>
+        => new()
+        {
+            BitsPerPixel = Unsafe.SizeOf<TPixel>() * 8,
+            ComponentInfo = info,
+            ColorType = colorType,
+            AlphaRepresentation = alphaRepresentation
+        };
+}
diff --git a/src/ImageSharp/PixelFormats/README.md b/src/ImageSharp/PixelFormats/README.md
index cbebaf23a..4c7ee545a 100644
--- a/src/ImageSharp/PixelFormats/README.md
+++ b/src/ImageSharp/PixelFormats/README.md
@@ -1,4 +1,4 @@
-Pixel formats adapted and extended from:
+Pixel formats adapted and extended from:
 
 https://github.com/MonoGame/MonoGame
 
diff --git a/src/ImageSharp/PixelFormats/Utils/Vector4Converters.Default.cs b/src/ImageSharp/PixelFormats/Utils/Vector4Converters.Default.cs
index 4d07a8a9b..d7cac1530 100644
--- a/src/ImageSharp/PixelFormats/Utils/Vector4Converters.Default.cs
+++ b/src/ImageSharp/PixelFormats/Utils/Vector4Converters.Default.cs
@@ -21,139 +21,139 @@ internal static partial class Vector4Converters
     {
         [MethodImpl(InliningOptions.ShortMethod)]
         public static void FromVector4<TPixel>(
-            Span<Vector4> sourceVectors,
-            Span<TPixel> destPixels,
+            Span<Vector4> source,
+            Span<TPixel> destination,
             PixelConversionModifiers modifiers)
             where TPixel : unmanaged, IPixel<TPixel>
         {
-            Guard.DestinationShouldNotBeTooShort(sourceVectors, destPixels, nameof(destPixels));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            UnsafeFromVector4(sourceVectors, destPixels, modifiers);
+            UnsafeFromVector4(source, destination, modifiers);
         }
 
         [MethodImpl(InliningOptions.ShortMethod)]
         public static void ToVector4<TPixel>(
-            ReadOnlySpan<TPixel> sourcePixels,
-            Span<Vector4> destVectors,
+            ReadOnlySpan<TPixel> source,
+            Span<Vector4> destination,
             PixelConversionModifiers modifiers)
             where TPixel : unmanaged, IPixel<TPixel>
         {
-            Guard.DestinationShouldNotBeTooShort(sourcePixels, destVectors, nameof(destVectors));
+            Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-            UnsafeToVector4(sourcePixels, destVectors, modifiers);
+            UnsafeToVector4(source, destination, modifiers);
         }
 
         [MethodImpl(InliningOptions.ShortMethod)]
         public static void UnsafeFromVector4<TPixel>(
-            Span<Vector4> sourceVectors,
-            Span<TPixel> destPixels,
+            Span<Vector4> source,
+            Span<TPixel> destination,
             PixelConversionModifiers modifiers)
             where TPixel : unmanaged, IPixel<TPixel>
         {
-            ApplyBackwardConversionModifiers(sourceVectors, modifiers);
+            ApplyBackwardConversionModifiers(source, modifiers);
 
             if (modifiers.IsDefined(PixelConversionModifiers.Scale))
             {
-                UnsafeFromScaledVector4Core(sourceVectors, destPixels);
+                UnsafeFromScaledVector4Core(source, destination);
             }
             else
             {
-                UnsafeFromVector4Core(sourceVectors, destPixels);
+                UnsafeFromVector4Core(source, destination);
             }
         }
 
         [MethodImpl(InliningOptions.ShortMethod)]
         public static void UnsafeToVector4<TPixel>(
-            ReadOnlySpan<TPixel> sourcePixels,
-            Span<Vector4> destVectors,
+            ReadOnlySpan<TPixel> source,
+            Span<Vector4> destination,
             PixelConversionModifiers modifiers)
             where TPixel : unmanaged, IPixel<TPixel>
         {
             if (modifiers.IsDefined(PixelConversionModifiers.Scale))
             {
-                UnsafeToScaledVector4Core(sourcePixels, destVectors);
+                UnsafeToScaledVector4Core(source, destination);
             }
             else
             {
-                UnsafeToVector4Core(sourcePixels, destVectors);
+                UnsafeToVector4Core(source, destination);
             }
 
-            ApplyForwardConversionModifiers(destVectors, modifiers);
+            ApplyForwardConversionModifiers(destination, modifiers);
         }
 
         [MethodImpl(InliningOptions.ShortMethod)]
         private static void UnsafeFromVector4Core<TPixel>(
-            ReadOnlySpan<Vector4> sourceVectors,
-            Span<TPixel> destPixels)
+            ReadOnlySpan<Vector4> source,
+            Span<TPixel> destination)
             where TPixel : unmanaged, IPixel<TPixel>
         {
-            ref Vector4 sourceStart = ref MemoryMarshal.GetReference(sourceVectors);
-            ref Vector4 sourceEnd = ref Unsafe.Add(ref sourceStart, (uint)sourceVectors.Length);
-            ref TPixel destRef = ref MemoryMarshal.GetReference(destPixels);
+            ref Vector4 sourceStart = ref MemoryMarshal.GetReference(source);
+            ref Vector4 sourceEnd = ref Unsafe.Add(ref sourceStart, (uint)source.Length);
+            ref TPixel destinationBase = ref MemoryMarshal.GetReference(destination);
 
             while (Unsafe.IsAddressLessThan(ref sourceStart, ref sourceEnd))
             {
-                destRef.FromVector4(sourceStart);
+                destinationBase = TPixel.FromVector4(sourceStart);
 
                 sourceStart = ref Unsafe.Add(ref sourceStart, 1);
-                destRef = ref Unsafe.Add(ref destRef, 1);
+                destinationBase = ref Unsafe.Add(ref destinationBase, 1);
             }
         }
 
         [MethodImpl(InliningOptions.ShortMethod)]
         private static void UnsafeToVector4Core<TPixel>(
-            ReadOnlySpan<TPixel> sourcePixels,
-            Span<Vector4> destVectors)
+            ReadOnlySpan<TPixel> source,
+            Span<Vector4> destination)
             where TPixel : unmanaged, IPixel<TPixel>
         {
-            ref TPixel sourceStart = ref MemoryMarshal.GetReference(sourcePixels);
-            ref TPixel sourceEnd = ref Unsafe.Add(ref sourceStart, (uint)sourcePixels.Length);
-            ref Vector4 destRef = ref MemoryMarshal.GetReference(destVectors);
+            ref TPixel sourceStart = ref MemoryMarshal.GetReference(source);
+            ref TPixel sourceEnd = ref Unsafe.Add(ref sourceStart, (uint)source.Length);
+            ref Vector4 destinationBase = ref MemoryMarshal.GetReference(destination);
 
             while (Unsafe.IsAddressLessThan(ref sourceStart, ref sourceEnd))
             {
-                destRef = sourceStart.ToVector4();
+                destinationBase = sourceStart.ToVector4();
 
                 sourceStart = ref Unsafe.Add(ref sourceStart, 1);
-                destRef = ref Unsafe.Add(ref destRef, 1);
+                destinationBase = ref Unsafe.Add(ref destinationBase, 1);
             }
         }
 
         [MethodImpl(InliningOptions.ShortMethod)]
         private static void UnsafeFromScaledVector4Core<TPixel>(
-            ReadOnlySpan<Vector4> sourceVectors,
-            Span<TPixel> destinationColors)
+            ReadOnlySpan<Vector4> source,
+            Span<TPixel> destination)
             where TPixel : unmanaged, IPixel<TPixel>
         {
-            ref Vector4 sourceStart = ref MemoryMarshal.GetReference(sourceVectors);
-            ref Vector4 sourceEnd = ref Unsafe.Add(ref sourceStart, (uint)sourceVectors.Length);
-            ref TPixel destRef = ref MemoryMarshal.GetReference(destinationColors);
+            ref Vector4 sourceStart = ref MemoryMarshal.GetReference(source);
+            ref Vector4 sourceEnd = ref Unsafe.Add(ref sourceStart, (uint)source.Length);
+            ref TPixel destinationBase = ref MemoryMarshal.GetReference(destination);
 
             while (Unsafe.IsAddressLessThan(ref sourceStart, ref sourceEnd))
             {
-                destRef.FromScaledVector4(sourceStart);
+                destinationBase = TPixel.FromScaledVector4(sourceStart);
 
                 sourceStart = ref Unsafe.Add(ref sourceStart, 1);
-                destRef = ref Unsafe.Add(ref destRef, 1);
+                destinationBase = ref Unsafe.Add(ref destinationBase, 1);
             }
         }
 
         [MethodImpl(InliningOptions.ShortMethod)]
         private static void UnsafeToScaledVector4Core<TPixel>(
-            ReadOnlySpan<TPixel> sourceColors,
-            Span<Vector4> destinationVectors)
+            ReadOnlySpan<TPixel> source,
+            Span<Vector4> destination)
             where TPixel : unmanaged, IPixel<TPixel>
         {
-            ref TPixel sourceStart = ref MemoryMarshal.GetReference(sourceColors);
-            ref TPixel sourceEnd = ref Unsafe.Add(ref sourceStart, (uint)sourceColors.Length);
-            ref Vector4 destRef = ref MemoryMarshal.GetReference(destinationVectors);
+            ref TPixel sourceStart = ref MemoryMarshal.GetReference(source);
+            ref TPixel sourceEnd = ref Unsafe.Add(ref sourceStart, (uint)source.Length);
+            ref Vector4 destinationBase = ref MemoryMarshal.GetReference(destination);
 
             while (Unsafe.IsAddressLessThan(ref sourceStart, ref sourceEnd))
             {
-                destRef = sourceStart.ToScaledVector4();
+                destinationBase = sourceStart.ToScaledVector4();
 
                 sourceStart = ref Unsafe.Add(ref sourceStart, 1);
-                destRef = ref Unsafe.Add(ref destRef, 1);
+                destinationBase = ref Unsafe.Add(ref destinationBase, 1);
             }
         }
     }
diff --git a/src/ImageSharp/PixelFormats/Utils/Vector4Converters.RgbaCompatible.cs b/src/ImageSharp/PixelFormats/Utils/Vector4Converters.RgbaCompatible.cs
index 3442a0807..8616ecb3b 100644
--- a/src/ImageSharp/PixelFormats/Utils/Vector4Converters.RgbaCompatible.cs
+++ b/src/ImageSharp/PixelFormats/Utils/Vector4Converters.RgbaCompatible.cs
@@ -28,7 +28,7 @@ internal static partial class Vector4Converters
         private static readonly int Vector4ConversionThreshold = CalculateVector4ConversionThreshold();
 
         /// <summary>
-        /// Provides an efficient default implementation for <see cref="PixelOperations{TPixel}.ToVector4(SixLabors.ImageSharp.Configuration,System.ReadOnlySpan{TPixel},System.Span{System.Numerics.Vector4},SixLabors.ImageSharp.PixelFormats.PixelConversionModifiers)"/>
+        /// Provides an efficient default implementation for <see cref="PixelOperations{TPixel}.ToVector4(Configuration,ReadOnlySpan{TPixel},Span{Vector4},PixelConversionModifiers)"/>
         /// The method works by internally converting to a <see cref="Rgba32"/> therefore it's not applicable for that type!
         /// </summary>
         [MethodImpl(InliningOptions.ShortMethod)]
@@ -72,7 +72,7 @@ internal static partial class Vector4Converters
         }
 
         /// <summary>
-        /// Provides an efficient default implementation for <see cref="PixelOperations{TPixel}.FromVector4Destructive(SixLabors.ImageSharp.Configuration,System.Span{System.Numerics.Vector4},System.Span{TPixel},SixLabors.ImageSharp.PixelFormats.PixelConversionModifiers)"/>
+        /// Provides an efficient default implementation for <see cref="PixelOperations{TPixel}.FromVector4Destructive(Configuration,Span{Vector4},Span{TPixel},PixelConversionModifiers)"/>
         /// The method is works by internally converting to a <see cref="Rgba32"/> therefore it's not applicable for that type!
         /// </summary>
         [MethodImpl(InliningOptions.ShortMethod)]
@@ -102,16 +102,14 @@ internal static partial class Vector4Converters
 
             // For the opposite direction it's not easy to implement the trick used in RunRgba32CompatibleToVector4Conversion,
             // so let's allocate a temporary buffer as usually:
-            using (IMemoryOwner<Rgba32> tempBuffer = configuration.MemoryAllocator.Allocate<Rgba32>(count))
-            {
-                Span<Rgba32> tempSpan = tempBuffer.Memory.Span;
+            using IMemoryOwner<Rgba32> tempBuffer = configuration.MemoryAllocator.Allocate<Rgba32>(count);
+            Span<Rgba32> tempSpan = tempBuffer.Memory.Span;
 
-                SimdUtils.NormalizedFloatToByteSaturate(
-                    MemoryMarshal.Cast<Vector4, float>(sourceVectors),
-                    MemoryMarshal.Cast<Rgba32, byte>(tempSpan));
+            SimdUtils.NormalizedFloatToByteSaturate(
+                MemoryMarshal.Cast<Vector4, float>(sourceVectors),
+                MemoryMarshal.Cast<Rgba32, byte>(tempSpan));
 
-                pixelOperations.FromRgba32(configuration, tempSpan, destPixels);
-            }
+            pixelOperations.FromRgba32(configuration, tempSpan, destPixels);
         }
 
         private static int CalculateVector4ConversionThreshold()
diff --git a/src/ImageSharp/Processing/Processors/Convolution/EdgeDetectorCompassProcessor{TPixel}.cs b/src/ImageSharp/Processing/Processors/Convolution/EdgeDetectorCompassProcessor{TPixel}.cs
index cbf893915..ae891f350 100644
--- a/src/ImageSharp/Processing/Processors/Convolution/EdgeDetectorCompassProcessor{TPixel}.cs
+++ b/src/ImageSharp/Processing/Processors/Convolution/EdgeDetectorCompassProcessor{TPixel}.cs
@@ -125,10 +125,7 @@ internal class EdgeDetectorCompassProcessor<TPixel> : ImageProcessor<TPixel>
                 // Grab the max components of the two pixels
                 ref TPixel currentPassPixel = ref Unsafe.Add(ref passPixelsBase, x);
                 ref TPixel currentTargetPixel = ref Unsafe.Add(ref targetPixelsBase, x);
-
-                var pixelValue = Vector4.Max(currentPassPixel.ToVector4(), currentTargetPixel.ToVector4());
-
-                currentTargetPixel.FromVector4(pixelValue);
+                currentTargetPixel = TPixel.FromVector4(Vector4.Max(currentPassPixel.ToVector4(), currentTargetPixel.ToVector4()));
             }
         }
     }
diff --git a/src/ImageSharp/Processing/Processors/Dithering/ErrorDither.cs b/src/ImageSharp/Processing/Processors/Dithering/ErrorDither.cs
index f1d7fbd6f..3c0ebb707 100644
--- a/src/ImageSharp/Processing/Processors/Dithering/ErrorDither.cs
+++ b/src/ImageSharp/Processing/Processors/Dithering/ErrorDither.cs
@@ -203,7 +203,7 @@ public readonly partial struct ErrorDither : IDither, IEquatable<ErrorDither>, I
                 Vector4 result = pixel.ToVector4();
 
                 result += error * coefficient;
-                pixel.FromVector4(result);
+                pixel = TPixel.FromVector4(result);
             }
         }
 
diff --git a/src/ImageSharp/Processing/Processors/Dithering/OrderedDither.cs b/src/ImageSharp/Processing/Processors/Dithering/OrderedDither.cs
index 1a02e7a22..d1f46c744 100644
--- a/src/ImageSharp/Processing/Processors/Dithering/OrderedDither.cs
+++ b/src/ImageSharp/Processing/Processors/Dithering/OrderedDither.cs
@@ -181,8 +181,7 @@ public readonly partial struct OrderedDither : IDither, IEquatable<OrderedDither
         float scale)
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        Unsafe.SkipInit(out Rgba32 rgba);
-        source.ToRgba32(ref rgba);
+        Rgba32 rgba = source.ToRgba32();
         Unsafe.SkipInit(out Rgba32 attempt);
 
         float factor = spread * this.thresholdMatrix[y % this.modulusY, x % this.modulusX] * scale;
@@ -192,10 +191,7 @@ public readonly partial struct OrderedDither : IDither, IEquatable<OrderedDither
         attempt.B = (byte)Numerics.Clamp(rgba.B + factor, byte.MinValue, byte.MaxValue);
         attempt.A = (byte)Numerics.Clamp(rgba.A + factor, byte.MinValue, byte.MaxValue);
 
-        TPixel result = default;
-        result.FromRgba32(attempt);
-
-        return result;
+        return TPixel.FromRgba32(attempt);
     }
 
     /// <inheritdoc/>
diff --git a/src/ImageSharp/Processing/Processors/Filters/LomographProcessor{TPixel}.cs b/src/ImageSharp/Processing/Processors/Filters/LomographProcessor{TPixel}.cs
index 4a02642fd..c8a381d59 100644
--- a/src/ImageSharp/Processing/Processors/Filters/LomographProcessor{TPixel}.cs
+++ b/src/ImageSharp/Processing/Processors/Filters/LomographProcessor{TPixel}.cs
@@ -12,7 +12,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Filters;
 internal class LomographProcessor<TPixel> : FilterProcessor<TPixel>
     where TPixel : unmanaged, IPixel<TPixel>
 {
-    private static readonly Color VeryDarkGreen = Color.FromRgba(0, 10, 0, 255);
+    private static readonly Color VeryDarkGreen = Color.FromPixel(new Rgba32(0, 10, 0, 255));
     private readonly LomographProcessor definition;
 
     /// <summary>
diff --git a/src/ImageSharp/Processing/Processors/Filters/PolaroidProcessor{TPixel}.cs b/src/ImageSharp/Processing/Processors/Filters/PolaroidProcessor{TPixel}.cs
index c1b79d10a..84c0364fa 100644
--- a/src/ImageSharp/Processing/Processors/Filters/PolaroidProcessor{TPixel}.cs
+++ b/src/ImageSharp/Processing/Processors/Filters/PolaroidProcessor{TPixel}.cs
@@ -12,8 +12,8 @@ namespace SixLabors.ImageSharp.Processing.Processors.Filters;
 internal class PolaroidProcessor<TPixel> : FilterProcessor<TPixel>
     where TPixel : unmanaged, IPixel<TPixel>
 {
-    private static readonly Color LightOrange = Color.FromRgba(255, 153, 102, 128);
-    private static readonly Color VeryDarkOrange = Color.FromRgb(102, 34, 0);
+    private static readonly Color LightOrange = Color.FromPixel(new Rgba32(255, 153, 102, 128));
+    private static readonly Color VeryDarkOrange = Color.FromPixel(new Rgb24(102, 34, 0));
     private readonly PolaroidProcessor definition;
 
     /// <summary>
diff --git a/src/ImageSharp/Processing/Processors/Normalization/AdaptiveHistogramEqualizationProcessor{TPixel}.cs b/src/ImageSharp/Processing/Processors/Normalization/AdaptiveHistogramEqualizationProcessor{TPixel}.cs
index 0baa87a61..78085eaab 100644
--- a/src/ImageSharp/Processing/Processors/Normalization/AdaptiveHistogramEqualizationProcessor{TPixel}.cs
+++ b/src/ImageSharp/Processing/Processors/Normalization/AdaptiveHistogramEqualizationProcessor{TPixel}.cs
@@ -64,11 +64,11 @@ internal class AdaptiveHistogramEqualizationProcessor<TPixel> : HistogramEqualiz
         int luminanceLevels = this.LuminanceLevels;
 
         // The image is split up into tiles. For each tile the cumulative distribution function will be calculated.
-        using (var cdfData = new CdfTileData(this.Configuration, sourceWidth, sourceHeight, this.Tiles, this.Tiles, tileWidth, tileHeight, luminanceLevels))
+        using (CdfTileData cdfData = new(this.Configuration, sourceWidth, sourceHeight, this.Tiles, this.Tiles, tileWidth, tileHeight, luminanceLevels))
         {
             cdfData.CalculateLookupTables(source, this);
 
-            var tileYStartPositions = new List<(int Y, int CdfY)>();
+            List<(int Y, int CdfY)> tileYStartPositions = [];
             int cdfY = 0;
             int yStart = halfTileHeight;
             for (int tile = 0; tile < tileCount - 1; tile++)
@@ -78,7 +78,7 @@ internal class AdaptiveHistogramEqualizationProcessor<TPixel> : HistogramEqualiz
                 yStart += tileHeight;
             }
 
-            var operation = new RowIntervalOperation(cdfData, tileYStartPositions, tileWidth, tileHeight, tileCount, halfTileWidth, luminanceLevels, source.PixelBuffer);
+            RowIntervalOperation operation = new(cdfData, tileYStartPositions, tileWidth, tileHeight, tileCount, halfTileWidth, luminanceLevels, source.PixelBuffer);
             ParallelRowIterator.IterateRowIntervals(
                 this.Configuration,
                 new Rectangle(0, 0, sourceWidth, tileYStartPositions.Count),
@@ -145,7 +145,7 @@ internal class AdaptiveHistogramEqualizationProcessor<TPixel> : HistogramEqualiz
             {
                 ref TPixel pixel = ref rowSpan[dx];
                 float luminanceEqualized = cdfData.RemapGreyValue(cdfX, cdfY, GetLuminance(pixel, luminanceLevels));
-                pixel.FromVector4(new Vector4(luminanceEqualized, luminanceEqualized, luminanceEqualized, pixel.ToVector4().W));
+                pixel = TPixel.FromVector4(new(luminanceEqualized, luminanceEqualized, luminanceEqualized, pixel.ToVector4().W));
             }
         }
     }
@@ -191,7 +191,7 @@ internal class AdaptiveHistogramEqualizationProcessor<TPixel> : HistogramEqualiz
                 {
                     ref TPixel pixel = ref rowSpan[dx];
                     float luminanceEqualized = InterpolateBetweenTwoTiles(pixel, cdfData, cdfX, cdfY, cdfX, cdfY + 1, tileY, tileHeight, luminanceLevels);
-                    pixel.FromVector4(new Vector4(luminanceEqualized, luminanceEqualized, luminanceEqualized, pixel.ToVector4().W));
+                    pixel = TPixel.FromVector4(new Vector4(luminanceEqualized, luminanceEqualized, luminanceEqualized, pixel.ToVector4().W));
                 }
 
                 tileY++;
@@ -243,7 +243,7 @@ internal class AdaptiveHistogramEqualizationProcessor<TPixel> : HistogramEqualiz
                 {
                     ref TPixel pixel = ref rowSpan[dx];
                     float luminanceEqualized = InterpolateBetweenTwoTiles(pixel, cdfData, cdfX, cdfY, cdfX + 1, cdfY, tileX, tileWidth, luminanceLevels);
-                    pixel.FromVector4(new Vector4(luminanceEqualized, luminanceEqualized, luminanceEqualized, pixel.ToVector4().W));
+                    pixel = TPixel.FromVector4(new Vector4(luminanceEqualized, luminanceEqualized, luminanceEqualized, pixel.ToVector4().W));
                     tileX++;
                 }
             }
@@ -404,10 +404,7 @@ internal class AdaptiveHistogramEqualizationProcessor<TPixel> : HistogramEqualiz
         {
             for (int index = rows.Min; index < rows.Max; index++)
             {
-                (int Y, int CdfY) tileYStartPosition = this.tileYStartPositions[index];
-                int y = tileYStartPosition.Y;
-                int cdfYY = tileYStartPosition.CdfY;
-
+                (int y, int cdfY) = this.tileYStartPositions[index];
                 int cdfX = 0;
                 int x = this.halfTileWidth;
                 for (int tile = 0; tile < this.tileCount - 1; tile++)
@@ -430,12 +427,12 @@ internal class AdaptiveHistogramEqualizationProcessor<TPixel> : HistogramEqualiz
                                 tileX,
                                 tileY,
                                 cdfX,
-                                cdfYY,
+                                cdfY,
                                 this.tileWidth,
                                 this.tileHeight,
                                 this.luminanceLevels);
 
-                            pixel.FromVector4(new Vector4(luminanceEqualized, luminanceEqualized, luminanceEqualized, pixel.ToVector4().W));
+                            pixel = TPixel.FromVector4(new Vector4(luminanceEqualized, luminanceEqualized, luminanceEqualized, pixel.ToVector4().W));
                             tileX++;
                         }
 
@@ -494,7 +491,7 @@ internal class AdaptiveHistogramEqualizationProcessor<TPixel> : HistogramEqualiz
             this.pixelsInTile = tileWidth * tileHeight;
 
             // Calculate the start positions and rent buffers.
-            this.tileYStartPositions = new List<(int Y, int CdfY)>();
+            this.tileYStartPositions = [];
             int cdfY = 0;
             for (int y = 0; y < sourceHeight; y += tileHeight)
             {
@@ -505,7 +502,7 @@ internal class AdaptiveHistogramEqualizationProcessor<TPixel> : HistogramEqualiz
 
         public void CalculateLookupTables(ImageFrame<TPixel> source, HistogramEqualizationProcessor<TPixel> processor)
         {
-            var operation = new RowIntervalOperation(
+            RowIntervalOperation operation = new(
                 processor,
                 this.memoryAllocator,
                 this.cdfMinBuffer2D,
diff --git a/src/ImageSharp/Processing/Processors/Normalization/AdaptiveHistogramEqualizationSlidingWindowProcessor{TPixel}.cs b/src/ImageSharp/Processing/Processors/Normalization/AdaptiveHistogramEqualizationSlidingWindowProcessor{TPixel}.cs
index d2bec0b49..93144653e 100644
--- a/src/ImageSharp/Processing/Processors/Normalization/AdaptiveHistogramEqualizationSlidingWindowProcessor{TPixel}.cs
+++ b/src/ImageSharp/Processing/Processors/Normalization/AdaptiveHistogramEqualizationSlidingWindowProcessor{TPixel}.cs
@@ -383,7 +383,7 @@ internal class AdaptiveHistogramEqualizationSlidingWindowProcessor<TPixel> : His
                     // Map the current pixel to the new equalized value.
                     int luminance = GetLuminance(this.source[x, y], this.processor.LuminanceLevels);
                     float luminanceEqualized = Unsafe.Add(ref cdfBase, (uint)luminance) / numberOfPixelsMinusCdfMin;
-                    this.targetPixels[x, y].FromVector4(new Vector4(luminanceEqualized, luminanceEqualized, luminanceEqualized, this.source[x, y].ToVector4().W));
+                    this.targetPixels[x, y] = TPixel.FromVector4(new(luminanceEqualized, luminanceEqualized, luminanceEqualized, this.source[x, y].ToVector4().W));
 
                     // Remove top most row from the histogram, mirroring rows which exceeds the borders.
                     if (this.useFastPath)
diff --git a/src/ImageSharp/Processing/Processors/Quantization/EuclideanPixelMap{TPixel}.cs b/src/ImageSharp/Processing/Processors/Quantization/EuclideanPixelMap{TPixel}.cs
index 72148374a..4fd37d479 100644
--- a/src/ImageSharp/Processing/Processors/Quantization/EuclideanPixelMap{TPixel}.cs
+++ b/src/ImageSharp/Processing/Processors/Quantization/EuclideanPixelMap{TPixel}.cs
@@ -55,8 +55,7 @@ internal sealed class EuclideanPixelMap<TPixel> : IDisposable
         PixelOperations<TPixel>.Instance.ToRgba32(configuration, this.Palette.Span, this.rgbaPalette);
 
         this.transparentIndex = transparentIndex;
-        Unsafe.SkipInit(out this.transparentMatch);
-        this.transparentMatch.FromRgba32(default);
+        this.transparentMatch = TPixel.FromRgba32(default);
     }
 
     /// <summary>
@@ -76,8 +75,7 @@ internal sealed class EuclideanPixelMap<TPixel> : IDisposable
     public int GetClosestColor(TPixel color, out TPixel match)
     {
         ref TPixel paletteRef = ref MemoryMarshal.GetReference(this.Palette.Span);
-        Unsafe.SkipInit(out Rgba32 rgba);
-        color.ToRgba32(ref rgba);
+        Rgba32 rgba = color.ToRgba32();
 
         // Check if the color is in the lookup table
         if (!this.cache.TryGetValue(rgba, out short index))
diff --git a/src/ImageSharp/Processing/Processors/Quantization/OctreeQuantizer{TPixel}.cs b/src/ImageSharp/Processing/Processors/Quantization/OctreeQuantizer{TPixel}.cs
index 039417578..8b39b7457 100644
--- a/src/ImageSharp/Processing/Processors/Quantization/OctreeQuantizer{TPixel}.cs
+++ b/src/ImageSharp/Processing/Processors/Quantization/OctreeQuantizer{TPixel}.cs
@@ -277,8 +277,7 @@ public struct OctreeQuantizer<TPixel> : IQuantizer<TPixel>
         [MethodImpl(InliningOptions.ShortMethod)]
         public int GetPaletteIndex(TPixel color)
         {
-            Unsafe.SkipInit(out Rgba32 rgba);
-            color.ToRgba32(ref rgba);
+            Rgba32 rgba = color.ToRgba32();
             return this.root.GetPaletteIndex(ref rgba, 0);
         }
 
@@ -476,9 +475,7 @@ public struct OctreeQuantizer<TPixel> : IQuantizer<TPixel>
                         Vector3.Zero,
                         new Vector3(255));
 
-                    Unsafe.SkipInit(out TPixel pixel);
-                    pixel.FromRgba32(new Rgba32((byte)vector.X, (byte)vector.Y, (byte)vector.Z, byte.MaxValue));
-                    palette[index] = pixel;
+                    palette[index] = TPixel.FromRgba32(new Rgba32((byte)vector.X, (byte)vector.Y, (byte)vector.Z));
 
                     // Consume the next palette index
                     this.paletteIndex = index++;
diff --git a/src/ImageSharp/Processing/Processors/Quantization/WuQuantizer{TPixel}.cs b/src/ImageSharp/Processing/Processors/Quantization/WuQuantizer{TPixel}.cs
index e13975b56..ba2ab825a 100644
--- a/src/ImageSharp/Processing/Processors/Quantization/WuQuantizer{TPixel}.cs
+++ b/src/ImageSharp/Processing/Processors/Quantization/WuQuantizer{TPixel}.cs
@@ -142,8 +142,7 @@ internal struct WuQuantizer<TPixel> : IQuantizer<TPixel>
 
             if (moment.Weight > 0)
             {
-                ref TPixel color = ref paletteSpan[k];
-                color.FromScaledVector4(moment.Normalize());
+                paletteSpan[k] = TPixel.FromScaledVector4(moment.Normalize());
             }
         }
 
@@ -178,8 +177,7 @@ internal struct WuQuantizer<TPixel> : IQuantizer<TPixel>
             return (byte)this.pixelMap!.GetClosestColor(color, out match);
         }
 
-        Rgba32 rgba = default;
-        color.ToRgba32(ref rgba);
+        Rgba32 rgba = color.ToRgba32();
 
         const int shift = 8 - IndexBits;
         int r = rgba.R >> shift;
@@ -549,7 +547,7 @@ internal struct WuQuantizer<TPixel> : IQuantizer<TPixel>
     /// <param name="set1">The first set.</param>
     /// <param name="set2">The second set.</param>
     /// <returns>Returns a value indicating whether the box has been split.</returns>
-    private bool Cut(ref Box set1, ref Box set2)
+    private readonly bool Cut(ref Box set1, ref Box set2)
     {
         ReadOnlySpan<Moment> momentSpan = this.momentsOwner.GetSpan();
         Moment whole = Volume(ref set1, momentSpan);
diff --git a/src/ImageSharp/Processing/Processors/Transforms/Resize/ResizeProcessor{TPixel}.cs b/src/ImageSharp/Processing/Processors/Transforms/Resize/ResizeProcessor{TPixel}.cs
index 98c2523fa..cfc30edc0 100644
--- a/src/ImageSharp/Processing/Processors/Transforms/Resize/ResizeProcessor{TPixel}.cs
+++ b/src/ImageSharp/Processing/Processors/Transforms/Resize/ResizeProcessor{TPixel}.cs
@@ -197,7 +197,7 @@ internal class ResizeProcessor<TPixel> : TransformProcessor<TPixel>, IResampling
         bool compand,
         bool premultiplyAlpha)
     {
-        PixelAlphaRepresentation? alphaRepresentation = PixelOperations<TPixel>.Instance.GetPixelTypeInfo()?.AlphaRepresentation;
+        PixelAlphaRepresentation? alphaRepresentation = PixelOperations<TPixel>.Instance.GetPixelTypeInfo().AlphaRepresentation;
 
         // Premultiply only if alpha representation is unknown or Unassociated:
         bool needsPremultiplication = alphaRepresentation == null || alphaRepresentation.Value == PixelAlphaRepresentation.Unassociated;
diff --git a/tests/ImageSharp.Benchmarks/Bulk/FromRgba32Bytes.cs b/tests/ImageSharp.Benchmarks/Bulk/FromRgba32Bytes.cs
index bd938c9da..6cae20853 100644
--- a/tests/ImageSharp.Benchmarks/Bulk/FromRgba32Bytes.cs
+++ b/tests/ImageSharp.Benchmarks/Bulk/FromRgba32Bytes.cs
@@ -49,23 +49,17 @@ public abstract class FromRgba32Bytes<TPixel>
         for (int i = 0; i < this.Count; i++)
         {
             int i4 = i * 4;
-            var c = default(TPixel);
-            c.FromRgba32(new Rgba32(s[i4], s[i4 + 1], s[i4 + 2], s[i4 + 3]));
-            d[i] = c;
+            d[i] = TPixel.FromRgba32(new Rgba32(s[i4], s[i4 + 1], s[i4 + 2], s[i4 + 3]));
         }
     }
 
     [Benchmark(Baseline = true)]
     public void CommonBulk()
-    {
-        new PixelOperations<TPixel>().FromRgba32Bytes(this.configuration, this.source.GetSpan(), this.destination.GetSpan(), this.Count);
-    }
+        => new PixelOperations<TPixel>().FromRgba32Bytes(this.configuration, this.source.GetSpan(), this.destination.GetSpan(), this.Count);
 
     [Benchmark]
     public void OptimizedBulk()
-    {
-        PixelOperations<TPixel>.Instance.FromRgba32Bytes(this.configuration, this.source.GetSpan(), this.destination.GetSpan(), this.Count);
-    }
+        => PixelOperations<TPixel>.Instance.FromRgba32Bytes(this.configuration, this.source.GetSpan(), this.destination.GetSpan(), this.Count);
 }
 
 public class FromRgba32Bytes_ToRgba32 : FromRgba32Bytes<Rgba32>
diff --git a/tests/ImageSharp.Benchmarks/Bulk/FromVector4.cs b/tests/ImageSharp.Benchmarks/Bulk/FromVector4.cs
index d70c37ccb..ecd16b957 100644
--- a/tests/ImageSharp.Benchmarks/Bulk/FromVector4.cs
+++ b/tests/ImageSharp.Benchmarks/Bulk/FromVector4.cs
@@ -49,21 +49,17 @@ public abstract class FromVector4<TPixel>
         ref TPixel d = ref MemoryMarshal.GetReference(this.destination.GetSpan());
         for (nuint i = 0; i < (uint)this.Count; i++)
         {
-            Unsafe.Add(ref d, i).FromVector4(Unsafe.Add(ref s, i));
+            Unsafe.Add(ref d, i) = TPixel.FromVector4(Unsafe.Add(ref s, i));
         }
     }
 
     [Benchmark(Baseline = true)]
     public void PixelOperations_Base()
-    {
-        new PixelOperations<TPixel>().FromVector4Destructive(this.Configuration, this.source.GetSpan(), this.destination.GetSpan());
-    }
+        => new PixelOperations<TPixel>().FromVector4Destructive(this.Configuration, this.source.GetSpan(), this.destination.GetSpan());
 
     [Benchmark]
     public void PixelOperations_Specialized()
-    {
-        PixelOperations<TPixel>.Instance.FromVector4Destructive(this.Configuration, this.source.GetSpan(), this.destination.GetSpan());
-    }
+        => PixelOperations<TPixel>.Instance.FromVector4Destructive(this.Configuration, this.source.GetSpan(), this.destination.GetSpan());
 }
 
 public class FromVector4Rgba32 : FromVector4<Rgba32>
diff --git a/tests/ImageSharp.Benchmarks/Bulk/ToRgba32Bytes.cs b/tests/ImageSharp.Benchmarks/Bulk/ToRgba32Bytes.cs
index 6d3f8f952..19ab780c0 100644
--- a/tests/ImageSharp.Benchmarks/Bulk/ToRgba32Bytes.cs
+++ b/tests/ImageSharp.Benchmarks/Bulk/ToRgba32Bytes.cs
@@ -47,8 +47,7 @@ public abstract class ToRgba32Bytes<TPixel>
         {
             TPixel c = s[i];
             int i4 = i * 4;
-            Rgba32 rgba = default;
-            c.ToRgba32(ref rgba);
+            Rgba32 rgba = c.ToRgba32();
             d[i4] = rgba.R;
             d[i4 + 1] = rgba.G;
             d[i4 + 2] = rgba.B;
diff --git a/tests/ImageSharp.Benchmarks/General/GetSetPixel.cs b/tests/ImageSharp.Benchmarks/General/GetSetPixel.cs
index a6aac20c3..5ba7809e1 100644
--- a/tests/ImageSharp.Benchmarks/General/GetSetPixel.cs
+++ b/tests/ImageSharp.Benchmarks/General/GetSetPixel.cs
@@ -21,7 +21,7 @@ public class GetSetPixel
     public Rgba32 GetSetImageSharp()
     {
         using Image<Rgba32> image = new(400, 400);
-        image[200, 200] = Color.White;
+        image[200, 200] = Color.White.ToPixel<Rgba32>();
         return image[200, 200];
     }
 }
diff --git a/tests/ImageSharp.Benchmarks/General/PixelConversion/ITestPixel.cs b/tests/ImageSharp.Benchmarks/General/PixelConversion/ITestPixel.cs
index 8820406af..82f0da505 100644
--- a/tests/ImageSharp.Benchmarks/General/PixelConversion/ITestPixel.cs
+++ b/tests/ImageSharp.Benchmarks/General/PixelConversion/ITestPixel.cs
@@ -11,19 +11,23 @@ public interface ITestPixel<T>
 {
     void FromRgba32(Rgba32 source);
 
+    static abstract T StaticFromRgba32(Rgba32 source);
+
     void FromRgba32(ref Rgba32 source);
 
     void FromBytes(byte r, byte g, byte b, byte a);
 
     void FromVector4(Vector4 source);
 
+    static abstract T StaticFromVector4(Vector4 source);
+
     void FromVector4(ref Vector4 source);
 
     Rgba32 ToRgba32();
 
-    void CopyToRgba32(ref Rgba32 dest);
+    void CopyToRgba32(ref Rgba32 destination);
 
     Vector4 ToVector4();
 
-    void CopyToVector4(ref Vector4 dest);
+    void CopyToVector4(ref Vector4 destination);
 }
diff --git a/tests/ImageSharp.Benchmarks/General/PixelConversion/PixelConversion_ConvertFromRgba32.cs b/tests/ImageSharp.Benchmarks/General/PixelConversion/PixelConversion_ConvertFromRgba32.cs
index 8d1684982..1d83b94dc 100644
--- a/tests/ImageSharp.Benchmarks/General/PixelConversion/PixelConversion_ConvertFromRgba32.cs
+++ b/tests/ImageSharp.Benchmarks/General/PixelConversion/PixelConversion_ConvertFromRgba32.cs
@@ -13,25 +13,25 @@ namespace SixLabors.ImageSharp.Benchmarks.General.PixelConversion;
 
 public abstract class PixelConversion_ConvertFromRgba32
 {
-    internal struct ConversionRunner<T>
+    internal readonly struct ConversionRunner<T>
         where T : struct, ITestPixel<T>
     {
-        public readonly T[] Dest;
+        public readonly T[] Destination;
 
         public readonly Rgba32[] Source;
 
         public ConversionRunner(int count)
         {
-            this.Dest = new T[count];
+            this.Destination = new T[count];
             this.Source = new Rgba32[count];
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void RunByRefConversion()
+        public readonly void RunByRefConversion()
         {
-            int count = this.Dest.Length;
+            int count = this.Destination.Length;
 
-            ref T destBaseRef = ref this.Dest[0];
+            ref T destBaseRef = ref this.Destination[0];
             ref Rgba32 sourceBaseRef = ref this.Source[0];
 
             for (nuint i = 0; i < (uint)count; i++)
@@ -41,11 +41,11 @@ public abstract class PixelConversion_ConvertFromRgba32
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void RunByValConversion()
+        public readonly void RunByValConversion()
         {
-            int count = this.Dest.Length;
+            int count = this.Destination.Length;
 
-            ref T destBaseRef = ref this.Dest[0];
+            ref T destBaseRef = ref this.Destination[0];
             ref Rgba32 sourceBaseRef = ref this.Source[0];
 
             for (nuint i = 0; i < (uint)count; i++)
@@ -55,11 +55,25 @@ public abstract class PixelConversion_ConvertFromRgba32
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void RunFromBytesConversion()
+        public readonly void RunStaticByValConversion()
         {
-            int count = this.Dest.Length;
+            int count = this.Destination.Length;
 
-            ref T destBaseRef = ref this.Dest[0];
+            ref T destBaseRef = ref this.Destination[0];
+            ref Rgba32 sourceBaseRef = ref this.Source[0];
+
+            for (nuint i = 0; i < (uint)count; i++)
+            {
+                Unsafe.Add(ref destBaseRef, i) = T.StaticFromRgba32(Unsafe.Add(ref sourceBaseRef, i));
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public readonly void RunFromBytesConversion()
+        {
+            int count = this.Destination.Length;
+
+            ref T destBaseRef = ref this.Destination[0];
             ref Rgba32 sourceBaseRef = ref this.Source[0];
 
             for (nuint i = 0; i < (uint)count; i++)
@@ -74,6 +88,8 @@ public abstract class PixelConversion_ConvertFromRgba32
 
     internal ConversionRunner<TestArgb> PermutedRunnerRgbaToArgb;
 
+    internal ConversionRunner<TestRgbaVector> RunnerRgbaToRgbaVector;
+
     [Params(256, 2048)]
     public int Count { get; set; }
 
@@ -82,34 +98,29 @@ public abstract class PixelConversion_ConvertFromRgba32
     {
         this.CompatibleMemLayoutRunner = new ConversionRunner<TestRgba>(this.Count);
         this.PermutedRunnerRgbaToArgb = new ConversionRunner<TestArgb>(this.Count);
+        this.RunnerRgbaToRgbaVector = new ConversionRunner<TestRgbaVector>(this.Count);
     }
 }
 
 public class PixelConversion_ConvertFromRgba32_Compatible : PixelConversion_ConvertFromRgba32
 {
     [Benchmark(Baseline = true)]
-    public void ByRef()
-    {
-        this.CompatibleMemLayoutRunner.RunByRefConversion();
-    }
+    public void ByRef() => this.CompatibleMemLayoutRunner.RunByRefConversion();
 
     [Benchmark]
-    public void ByVal()
-    {
-        this.CompatibleMemLayoutRunner.RunByValConversion();
-    }
+    public void ByVal() => this.CompatibleMemLayoutRunner.RunByValConversion();
 
     [Benchmark]
-    public void FromBytes()
-    {
-        this.CompatibleMemLayoutRunner.RunFromBytesConversion();
-    }
+    public void StaticByVal() => this.CompatibleMemLayoutRunner.RunStaticByValConversion();
+
+    [Benchmark]
+    public void FromBytes() => this.CompatibleMemLayoutRunner.RunFromBytesConversion();
 
     [Benchmark]
     public void Inline()
     {
         ref Rgba32 sBase = ref this.CompatibleMemLayoutRunner.Source[0];
-        ref Rgba32 dBase = ref Unsafe.As<TestRgba, Rgba32>(ref this.CompatibleMemLayoutRunner.Dest[0]);
+        ref Rgba32 dBase = ref Unsafe.As<TestRgba, Rgba32>(ref this.CompatibleMemLayoutRunner.Destination[0]);
 
         for (nuint i = 0; i < (uint)this.Count; i++)
         {
@@ -117,39 +128,49 @@ public class PixelConversion_ConvertFromRgba32_Compatible : PixelConversion_Conv
         }
     }
 
-    /*   Method | Count |     Mean |    Error |   StdDev | Scaled | ScaledSD |
-     ---------- |------ |---------:|---------:|---------:|-------:|---------:|
-          ByRef |   256 | 128.5 ns | 1.217 ns | 1.138 ns |   1.00 |     0.00 |
-          ByVal |   256 | 196.7 ns | 2.792 ns | 2.612 ns |   1.53 |     0.02 |
-      FromBytes |   256 | 321.7 ns | 2.180 ns | 1.820 ns |   2.50 |     0.03 |
-         Inline |   256 | 129.9 ns | 2.759 ns | 2.581 ns |   1.01 |     0.02 | */
+    /*
+    BenchmarkDotNet v0.13.10, Windows 11 (10.0.22631.3007/23H2/2023Update/SunValley3)
+    11th Gen Intel Core i7-11370H 3.30GHz, 1 CPU, 8 logical and 4 physical cores
+    .NET SDK 8.0.200-preview.23624.5
+      [Host]     : .NET 8.0.1 (8.0.123.58001), X64 RyuJIT AVX2
+      DefaultJob : .NET 8.0.1 (8.0.123.58001), X64 RyuJIT AVX2
+
+
+    | Method      | Count | Mean       | Error   | StdDev  | Ratio |
+    |------------ |------ |-----------:|--------:|--------:|------:|
+    | ByRef       | 256   |   103.4 ns | 0.52 ns | 0.46 ns |  1.00 |
+    | ByVal       | 256   |   103.3 ns | 1.48 ns | 1.38 ns |  1.00 |
+    | StaticByVal | 256   |   104.0 ns | 0.36 ns | 0.30 ns |  1.01 |
+    | FromBytes   | 256   |   201.8 ns | 1.30 ns | 1.15 ns |  1.95 |
+    | Inline      | 256   |   106.6 ns | 0.40 ns | 0.34 ns |  1.03 |
+    |             |       |            |         |         |       |
+    | ByRef       | 2048  |   771.5 ns | 3.68 ns | 3.27 ns |  1.00 |
+    | ByVal       | 2048  |   769.7 ns | 3.39 ns | 2.83 ns |  1.00 |
+    | StaticByVal | 2048  |   773.2 ns | 3.95 ns | 3.50 ns |  1.00 |
+    | FromBytes   | 2048  | 1,555.3 ns | 9.24 ns | 8.19 ns |  2.02 |
+    | Inline      | 2048  |   799.5 ns | 5.91 ns | 4.93 ns |  1.04 |
+    */
 }
 
 public class PixelConversion_ConvertFromRgba32_Permuted_RgbaToArgb : PixelConversion_ConvertFromRgba32
 {
     [Benchmark(Baseline = true)]
-    public void ByRef()
-    {
-        this.PermutedRunnerRgbaToArgb.RunByRefConversion();
-    }
+    public void ByRef() => this.PermutedRunnerRgbaToArgb.RunByRefConversion();
 
     [Benchmark]
-    public void ByVal()
-    {
-        this.PermutedRunnerRgbaToArgb.RunByValConversion();
-    }
+    public void ByVal() => this.PermutedRunnerRgbaToArgb.RunByValConversion();
 
     [Benchmark]
-    public void FromBytes()
-    {
-        this.PermutedRunnerRgbaToArgb.RunFromBytesConversion();
-    }
+    public void StaticByVal() => this.PermutedRunnerRgbaToArgb.RunStaticByValConversion();
+
+    [Benchmark]
+    public void FromBytes() => this.PermutedRunnerRgbaToArgb.RunFromBytesConversion();
 
     [Benchmark]
     public void InlineShuffle()
     {
         ref Rgba32 sBase = ref this.PermutedRunnerRgbaToArgb.Source[0];
-        ref TestArgb dBase = ref this.PermutedRunnerRgbaToArgb.Dest[0];
+        ref TestArgb dBase = ref this.PermutedRunnerRgbaToArgb.Destination[0];
 
         for (nuint i = 0; i < (uint)this.Count; i++)
         {
@@ -167,25 +188,64 @@ public class PixelConversion_ConvertFromRgba32_Permuted_RgbaToArgb : PixelConver
     public void PixelConverter_Rgba32_ToArgb32()
     {
         Span<byte> source = MemoryMarshal.Cast<Rgba32, byte>(this.PermutedRunnerRgbaToArgb.Source);
-        Span<byte> dest = MemoryMarshal.Cast<TestArgb, byte>(this.PermutedRunnerRgbaToArgb.Dest);
+        Span<byte> dest = MemoryMarshal.Cast<TestArgb, byte>(this.PermutedRunnerRgbaToArgb.Destination);
 
         PixelConverter.FromRgba32.ToArgb32(source, dest);
     }
 
     /*
-    RESULTS:
-    |                         Method | Count |        Mean |     Error |    StdDev |      Median | Ratio | RatioSD |
-    |------------------------------- |------ |------------:|----------:|----------:|------------:|------:|--------:|
-    |                          ByRef |   256 |   288.84 ns | 19.601 ns | 52.319 ns |   268.10 ns |  1.00 |    0.00 |
-    |                          ByVal |   256 |   267.97 ns |  1.831 ns |  1.713 ns |   267.85 ns |  0.77 |    0.18 |
-    |                      FromBytes |   256 |   266.81 ns |  2.427 ns |  2.270 ns |   266.47 ns |  0.76 |    0.18 |
-    |                  InlineShuffle |   256 |   291.41 ns |  5.820 ns |  5.444 ns |   290.17 ns |  0.83 |    0.19 |
-    | PixelConverter_Rgba32_ToArgb32 |   256 |    38.62 ns |  0.431 ns |  0.403 ns |    38.68 ns |  0.11 |    0.03 |
-    |                                |       |             |           |           |             |       |         |
-    |                          ByRef |  2048 | 2,197.69 ns | 15.826 ns | 14.804 ns | 2,197.25 ns |  1.00 |    0.00 |
-    |                          ByVal |  2048 | 2,226.81 ns | 44.266 ns | 62.054 ns | 2,197.17 ns |  1.03 |    0.04 |
-    |                      FromBytes |  2048 | 2,181.35 ns | 18.033 ns | 16.868 ns | 2,185.97 ns |  0.99 |    0.01 |
-    |                  InlineShuffle |  2048 | 2,233.10 ns | 27.673 ns | 24.531 ns | 2,229.78 ns |  1.02 |    0.01 |
-    | PixelConverter_Rgba32_ToArgb32 |  2048 |   139.90 ns |  2.152 ns |  3.825 ns |   138.70 ns |  0.06 |    0.00 |
+    BenchmarkDotNet v0.13.10, Windows 11 (10.0.22631.3007/23H2/2023Update/SunValley3)
+    11th Gen Intel Core i7-11370H 3.30GHz, 1 CPU, 8 logical and 4 physical cores
+    .NET SDK 8.0.200-preview.23624.5
+      [Host]     : .NET 8.0.1 (8.0.123.58001), X64 RyuJIT AVX2
+      DefaultJob : .NET 8.0.1 (8.0.123.58001), X64 RyuJIT AVX2
+
+
+    | Method                         | Count | Mean        | Error     | StdDev   | Ratio | RatioSD |
+    |------------------------------- |------ |------------:|----------:|---------:|------:|--------:|
+    | ByRef                          | 256   |   203.48 ns |  3.318 ns | 3.104 ns |  1.00 |    0.00 |
+    | ByVal                          | 256   |   201.46 ns |  2.242 ns | 1.872 ns |  0.99 |    0.02 |
+    | StaticByVal                    | 256   |   201.45 ns |  0.791 ns | 0.701 ns |  0.99 |    0.02 |
+    | FromBytes                      | 256   |   200.76 ns |  1.365 ns | 1.140 ns |  0.99 |    0.01 |
+    | InlineShuffle                  | 256   |   221.65 ns |  2.104 ns | 1.968 ns |  1.09 |    0.02 |
+    | PixelConverter_Rgba32_ToArgb32 | 256   |    26.23 ns |  0.277 ns | 0.231 ns |  0.13 |    0.00 |
+    |                                |       |             |           |          |       |         |
+    | ByRef                          | 2048  | 1,561.54 ns | 11.208 ns | 8.751 ns |  1.00 |    0.00 |
+    | ByVal                          | 2048  | 1,554.26 ns |  9.607 ns | 8.517 ns |  1.00 |    0.01 |
+    | StaticByVal                    | 2048  | 1,562.48 ns |  8.937 ns | 8.360 ns |  1.00 |    0.01 |
+    | FromBytes                      | 2048  | 1,552.68 ns |  7.445 ns | 5.812 ns |  0.99 |    0.01 |
+    | InlineShuffle                  | 2048  | 1,711.28 ns |  7.559 ns | 6.312 ns |  1.10 |    0.01 |
+    | PixelConverter_Rgba32_ToArgb32 | 2048  |    94.43 ns |  0.363 ns | 0.322 ns |  0.06 |    0.00 |
+    */
+}
+
+public class PixelConversion_ConvertFromRgba32_RgbaToRgbaVector : PixelConversion_ConvertFromRgba32
+{
+    [Benchmark(Baseline = true)]
+    public void ByRef() => this.RunnerRgbaToRgbaVector.RunByRefConversion();
+
+    [Benchmark]
+    public void ByVal() => this.RunnerRgbaToRgbaVector.RunByValConversion();
+
+    [Benchmark]
+    public void StaticByVal() => this.RunnerRgbaToRgbaVector.RunStaticByValConversion();
+
+    /*
+    BenchmarkDotNet v0.13.10, Windows 11 (10.0.22631.3007/23H2/2023Update/SunValley3)
+    11th Gen Intel Core i7-11370H 3.30GHz, 1 CPU, 8 logical and 4 physical cores
+    .NET SDK 8.0.200-preview.23624.5
+      [Host]     : .NET 8.0.1 (8.0.123.58001), X64 RyuJIT AVX2
+      DefaultJob : .NET 8.0.1 (8.0.123.58001), X64 RyuJIT AVX2
+
+
+    | Method      | Count | Mean       | Error    | StdDev   | Ratio | RatioSD |
+    |------------ |------ |-----------:|---------:|---------:|------:|--------:|
+    | ByRef       | 256   |   448.5 ns |  4.86 ns |  4.06 ns |  1.00 |    0.00 |
+    | ByVal       | 256   |   447.0 ns |  1.55 ns |  1.21 ns |  1.00 |    0.01 |
+    | StaticByVal | 256   |   447.4 ns |  1.67 ns |  1.30 ns |  1.00 |    0.01 |
+    |             |       |            |          |          |       |         |
+    | ByRef       | 2048  | 3,577.7 ns | 53.80 ns | 47.69 ns |  1.00 |    0.00 |
+    | ByVal       | 2048  | 3,590.5 ns | 43.59 ns | 36.40 ns |  1.00 |    0.02 |
+    | StaticByVal | 2048  | 3,604.6 ns | 16.19 ns | 14.36 ns |  1.01 |    0.01 |
     */
 }
diff --git a/tests/ImageSharp.Benchmarks/General/PixelConversion/PixelConversion_ConvertFromVector4.cs b/tests/ImageSharp.Benchmarks/General/PixelConversion/PixelConversion_ConvertFromVector4.cs
index dd85d0641..57f79ba1f 100644
--- a/tests/ImageSharp.Benchmarks/General/PixelConversion/PixelConversion_ConvertFromVector4.cs
+++ b/tests/ImageSharp.Benchmarks/General/PixelConversion/PixelConversion_ConvertFromVector4.cs
@@ -13,43 +13,6 @@ namespace SixLabors.ImageSharp.Benchmarks.General.PixelConversion;
 
 public class PixelConversion_ConvertFromVector4
 {
-    [StructLayout(LayoutKind.Sequential)]
-    private struct TestRgbaVector : ITestPixel<TestRgbaVector>
-    {
-        private Vector4 v;
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void FromVector4(Vector4 p)
-        {
-            this.v = p;
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void FromVector4(ref Vector4 p)
-        {
-            this.v = p;
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public Vector4 ToVector4() => this.v;
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void CopyToVector4(ref Vector4 dest)
-        {
-            dest = this.v;
-        }
-
-        public void FromRgba32(Rgba32 source) => throw new System.NotImplementedException();
-
-        public void FromRgba32(ref Rgba32 source) => throw new System.NotImplementedException();
-
-        public void FromBytes(byte r, byte g, byte b, byte a) => throw new System.NotImplementedException();
-
-        public Rgba32 ToRgba32() => throw new System.NotImplementedException();
-
-        public void CopyToRgba32(ref Rgba32 dest) => throw new System.NotImplementedException();
-    }
-
     private struct ConversionRunner<T>
         where T : struct, ITestPixel<T>
     {
diff --git a/tests/ImageSharp.Benchmarks/General/PixelConversion/PixelConversion_Rgba32_To_Argb32.cs b/tests/ImageSharp.Benchmarks/General/PixelConversion/PixelConversion_Rgba32_To_Argb32.cs
index 0ee507832..a8c6a021a 100644
--- a/tests/ImageSharp.Benchmarks/General/PixelConversion/PixelConversion_Rgba32_To_Argb32.cs
+++ b/tests/ImageSharp.Benchmarks/General/PixelConversion/PixelConversion_Rgba32_To_Argb32.cs
@@ -12,8 +12,7 @@ namespace SixLabors.ImageSharp.Benchmarks.General.PixelConversion;
 public class PixelConversion_Rgba32_To_Argb32
 {
     private Rgba32[] source;
-
-    private Argb32[] dest;
+    private Argb32[] destination;
 
     [Params(64)]
     public int Count { get; set; }
@@ -22,19 +21,19 @@ public class PixelConversion_Rgba32_To_Argb32
     public void Setup()
     {
         this.source = new Rgba32[this.Count];
-        this.dest = new Argb32[this.Count];
+        this.destination = new Argb32[this.Count];
     }
 
     [Benchmark(Baseline = true)]
     public void Default()
     {
         ref Rgba32 sBase = ref this.source[0];
-        ref Argb32 dBase = ref this.dest[0];
+        ref Argb32 dBase = ref this.destination[0];
 
         for (nuint i = 0; i < (uint)this.Count; i++)
         {
             Rgba32 s = Unsafe.Add(ref sBase, i);
-            Unsafe.Add(ref dBase, i).FromRgba32(s);
+            Unsafe.Add(ref dBase, i) = Argb32.FromRgba32(s);
         }
     }
 
@@ -48,21 +47,18 @@ public class PixelConversion_Rgba32_To_Argb32
         for (nuint i = 0; i < (uint)source.Length; i++)
         {
             Rgba32 s = Unsafe.Add(ref sBase, i);
-            Unsafe.Add(ref dBase, i).FromRgba32(s);
+            Unsafe.Add(ref dBase, i) = TPixel.FromRgba32(s);
         }
     }
 
     [Benchmark]
-    public void Default_Generic()
-    {
-        Default_GenericImpl(this.source.AsSpan(), this.dest.AsSpan());
-    }
+    public void Default_Generic() => Default_GenericImpl(this.source.AsSpan(), this.destination.AsSpan());
 
     [Benchmark]
     public void Default_Group2()
     {
         ref Rgba32 sBase = ref this.source[0];
-        ref Argb32 dBase = ref this.dest[0];
+        ref Argb32 dBase = ref this.destination[0];
 
         for (nuint i = 0; i < (uint)this.Count; i += 2)
         {
@@ -70,8 +66,8 @@ public class PixelConversion_Rgba32_To_Argb32
             Rgba32 s1 = Unsafe.Add(ref s0, 1);
 
             ref Argb32 d0 = ref Unsafe.Add(ref dBase, i);
-            d0.FromRgba32(s0);
-            Unsafe.Add(ref d0, 1).FromRgba32(s1);
+            d0 = Argb32.FromRgba32(s0);
+            Unsafe.Add(ref d0, 1) = Argb32.FromRgba32(s1);
         }
     }
 
@@ -79,7 +75,7 @@ public class PixelConversion_Rgba32_To_Argb32
     public void Default_Group4()
     {
         ref Rgba32 sBase = ref this.source[0];
-        ref Argb32 dBase = ref this.dest[0];
+        ref Argb32 dBase = ref this.destination[0];
 
         for (nuint i = 0; i < (uint)this.Count; i += 4)
         {
@@ -92,10 +88,10 @@ public class PixelConversion_Rgba32_To_Argb32
             ref Argb32 d1 = ref Unsafe.Add(ref d0, 1);
             ref Argb32 d2 = ref Unsafe.Add(ref d1, 1);
 
-            d0.FromRgba32(s0);
-            d1.FromRgba32(s1);
-            d2.FromRgba32(s2);
-            Unsafe.Add(ref d2, 1).FromRgba32(s3);
+            d0 = Argb32.FromRgba32(s0);
+            d1 = Argb32.FromRgba32(s1);
+            d2 = Argb32.FromRgba32(s2);
+            Unsafe.Add(ref d2, 1) = Argb32.FromRgba32(s3);
         }
     }
 
@@ -103,7 +99,7 @@ public class PixelConversion_Rgba32_To_Argb32
     public void BitOps()
     {
         ref uint sBase = ref Unsafe.As<Rgba32, uint>(ref this.source[0]);
-        ref uint dBase = ref Unsafe.As<Argb32, uint>(ref this.dest[0]);
+        ref uint dBase = ref Unsafe.As<Argb32, uint>(ref this.destination[0]);
 
         for (nuint i = 0; i < (uint)this.Count; i++)
         {
@@ -116,7 +112,7 @@ public class PixelConversion_Rgba32_To_Argb32
     public void BitOps_GroupAsULong()
     {
         ref ulong sBase = ref Unsafe.As<Rgba32, ulong>(ref this.source[0]);
-        ref ulong dBase = ref Unsafe.As<Argb32, ulong>(ref this.dest[0]);
+        ref ulong dBase = ref Unsafe.As<Argb32, ulong>(ref this.destination[0]);
 
         for (nuint i = 0; i < (uint)this.Count / 2; i++)
         {
@@ -134,10 +130,6 @@ public class PixelConversion_Rgba32_To_Argb32
 
     public static class FromRgba32
     {
-        /// <summary>
-        /// Converts a packed <see cref="Rgba32"/> to <see cref="Argb32"/>.
-        /// </summary>
-        /// <returns>The argb value.</returns>
         [MethodImpl(InliningOptions.ShortMethod)]
         public static uint ToArgb32(uint packedRgba)
         {
@@ -146,10 +138,6 @@ public class PixelConversion_Rgba32_To_Argb32
             return (packedRgba << 8) | (packedRgba >> 24);
         }
 
-        /// <summary>
-        /// Converts a packed <see cref="Rgba32"/> to <see cref="Bgra32"/>.
-        /// </summary>
-        /// <returns>The bgra value.</returns>
         [MethodImpl(InliningOptions.ShortMethod)]
         public static uint ToBgra32(uint packedRgba)
         {
diff --git a/tests/ImageSharp.Benchmarks/General/PixelConversion/PixelConversion_Rgba32_To_Bgra32.cs b/tests/ImageSharp.Benchmarks/General/PixelConversion/PixelConversion_Rgba32_To_Bgra32.cs
index 499f3483d..f4fb9e420 100644
--- a/tests/ImageSharp.Benchmarks/General/PixelConversion/PixelConversion_Rgba32_To_Bgra32.cs
+++ b/tests/ImageSharp.Benchmarks/General/PixelConversion/PixelConversion_Rgba32_To_Bgra32.cs
@@ -55,7 +55,7 @@ public class PixelConversion_Rgba32_To_Bgra32
         for (nuint i = 0; i < (uint)this.Count; i++)
         {
             ref Rgba32 s = ref Unsafe.Add(ref sBase, i);
-            Unsafe.Add(ref dBase, i).FromRgba32(s);
+            Unsafe.Add(ref dBase, i) = Bgra32.FromRgba32(s);
         }
     }
 
@@ -69,15 +69,12 @@ public class PixelConversion_Rgba32_To_Bgra32
         for (nuint i = 0; i < (uint)source.Length; i++)
         {
             ref Rgba32 s = ref Unsafe.Add(ref sBase, i);
-            Unsafe.Add(ref dBase, i).FromRgba32(s);
+            Unsafe.Add(ref dBase, i) = TPixel.FromRgba32(s);
         }
     }
 
     [Benchmark]
-    public void Default_Generic()
-    {
-        Default_GenericImpl(this.source.AsSpan(), this.dest.AsSpan());
-    }
+    public void Default_Generic() => Default_GenericImpl(this.source.AsSpan(), this.dest.AsSpan());
 
     [Benchmark]
     public void Default_Group2()
@@ -91,8 +88,8 @@ public class PixelConversion_Rgba32_To_Bgra32
             Rgba32 s1 = Unsafe.Add(ref s0, 1);
 
             ref Bgra32 d0 = ref Unsafe.Add(ref dBase, i);
-            d0.FromRgba32(s0);
-            Unsafe.Add(ref d0, 1).FromRgba32(s1);
+            d0 = Bgra32.FromRgba32(s0);
+            Unsafe.Add(ref d0, 1) = Bgra32.FromRgba32(s1);
         }
     }
 
@@ -113,10 +110,10 @@ public class PixelConversion_Rgba32_To_Bgra32
             ref Bgra32 d1 = ref Unsafe.Add(ref d0, 1);
             ref Bgra32 d2 = ref Unsafe.Add(ref d1, 1);
 
-            d0.FromRgba32(s0);
-            d1.FromRgba32(s1);
-            d2.FromRgba32(s2);
-            Unsafe.Add(ref d2, 1).FromRgba32(s3);
+            d0 = Bgra32.FromRgba32(s0);
+            d1 = Bgra32.FromRgba32(s1);
+            d2 = Bgra32.FromRgba32(s2);
+            Unsafe.Add(ref d2, 1) = Bgra32.FromRgba32(s3);
         }
     }
 
@@ -138,18 +135,15 @@ public class PixelConversion_Rgba32_To_Bgra32
             ref TPixel d1 = ref Unsafe.Add(ref d0, 1);
             ref TPixel d2 = ref Unsafe.Add(ref d1, 1);
 
-            d0.FromRgba32(s0);
-            d1.FromRgba32(s1);
-            d2.FromRgba32(s2);
-            Unsafe.Add(ref d2, 1).FromRgba32(s3);
+            d0 = TPixel.FromRgba32(s0);
+            d1 = TPixel.FromRgba32(s1);
+            d2 = TPixel.FromRgba32(s2);
+            Unsafe.Add(ref d2, 1) = TPixel.FromRgba32(s3);
         }
     }
 
     // [Benchmark]
-    public void Default_Group4_Generic()
-    {
-        Group4GenericImpl(this.source.AsSpan(), this.dest.AsSpan());
-    }
+    public void Default_Group4_Generic() => Group4GenericImpl(this.source.AsSpan(), this.dest.AsSpan());
 
     // [Benchmark]
     public void Default_Group8()
@@ -178,15 +172,15 @@ public class PixelConversion_Rgba32_To_Bgra32
             ref Bgra32 d5 = ref Unsafe.Add(ref d4, 1);
             ref Bgra32 d6 = ref Unsafe.Add(ref d5, 1);
 
-            d0.FromRgba32(s0);
-            d1.FromRgba32(s1);
-            d2.FromRgba32(s2);
-            d3.FromRgba32(s3);
+            d0 = Bgra32.FromRgba32(s0);
+            d1 = Bgra32.FromRgba32(s1);
+            d2 = Bgra32.FromRgba32(s2);
+            d3 = Bgra32.FromRgba32(s3);
 
-            d4.FromRgba32(s4);
-            d5.FromRgba32(s5);
-            d6.FromRgba32(s6);
-            Unsafe.Add(ref d6, 1).FromRgba32(s7);
+            d4 = Bgra32.FromRgba32(s4);
+            d5 = Bgra32.FromRgba32(s5);
+            d6 = Bgra32.FromRgba32(s6);
+            Unsafe.Add(ref d6, 1) = Bgra32.FromRgba32(s7);
         }
     }
 
@@ -352,10 +346,6 @@ public class PixelConversion_Rgba32_To_Bgra32
 
     public static class FromRgba32
     {
-        /// <summary>
-        /// Converts a packed <see cref="Rgba32"/> to <see cref="Argb32"/>.
-        /// </summary>
-        /// <returns>The argb value.</returns>
         [MethodImpl(InliningOptions.ShortMethod)]
         public static uint ToArgb32(uint packedRgba)
         {
@@ -364,10 +354,6 @@ public class PixelConversion_Rgba32_To_Bgra32
             return (packedRgba << 8) | (packedRgba >> 24);
         }
 
-        /// <summary>
-        /// Converts a packed <see cref="Rgba32"/> to <see cref="Bgra32"/>.
-        /// </summary>
-        /// <returns>The bgra value.</returns>
         [MethodImpl(InliningOptions.ShortMethod)]
         public static uint ToBgra32(uint packedRgba)
         {
diff --git a/tests/ImageSharp.Benchmarks/General/PixelConversion/TestArgb.cs b/tests/ImageSharp.Benchmarks/General/PixelConversion/TestArgb.cs
index 84698a0e1..21bef5a15 100644
--- a/tests/ImageSharp.Benchmarks/General/PixelConversion/TestArgb.cs
+++ b/tests/ImageSharp.Benchmarks/General/PixelConversion/TestArgb.cs
@@ -4,6 +4,7 @@
 using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Benchmarks.General.PixelConversion;
@@ -16,26 +17,20 @@ public struct TestArgb : ITestPixel<TestArgb>
     public byte G;
     public byte B;
 
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public void FromRgba32(Rgba32 p)
-    {
-        this.R = p.R;
-        this.G = p.G;
-        this.B = p.B;
-        this.A = p.A;
-    }
+    private static readonly Vector4 MaxBytes = Vector128.Create(255f).AsVector4();
+    private static readonly Vector4 Half = Vector128.Create(.5f).AsVector4();
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public void FromRgba32(ref Rgba32 p)
+    private TestArgb(Rgba32 source)
     {
-        this.R = p.R;
-        this.G = p.G;
-        this.B = p.B;
-        this.A = p.A;
+        this.R = source.R;
+        this.G = source.G;
+        this.B = source.B;
+        this.A = source.A;
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public void FromBytes(byte r, byte g, byte b, byte a)
+    private TestArgb(byte r, byte g, byte b, byte a)
     {
         this.R = r;
         this.G = g;
@@ -44,50 +39,70 @@ public struct TestArgb : ITestPixel<TestArgb>
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public void FromVector4(Vector4 p)
+    public void FromRgba32(Rgba32 source)
     {
-        this.R = (byte)p.X;
-        this.G = (byte)p.Y;
-        this.B = (byte)p.Z;
-        this.A = (byte)p.W;
+        this.R = source.R;
+        this.G = source.G;
+        this.B = source.B;
+        this.A = source.A;
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public void FromVector4(ref Vector4 p)
+    public void FromRgba32(ref Rgba32 source)
     {
-        this.R = (byte)p.X;
-        this.G = (byte)p.Y;
-        this.B = (byte)p.Z;
-        this.A = (byte)p.W;
+        this.R = source.R;
+        this.G = source.G;
+        this.B = source.B;
+        this.A = source.A;
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public Rgba32 ToRgba32()
-    {
-        return new Rgba32(this.R, this.G, this.B, this.A);
-    }
+    public static TestArgb StaticFromRgba32(Rgba32 source) => new(source);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public void CopyToRgba32(ref Rgba32 dest)
+    public void FromBytes(byte r, byte g, byte b, byte a)
     {
-        dest.R = this.R;
-        dest.G = this.G;
-        dest.B = this.B;
-        dest.A = this.A;
+        this.R = r;
+        this.G = g;
+        this.B = b;
+        this.A = a;
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public Vector4 ToVector4()
+    public void FromVector4(Vector4 source) => this = Pack(source);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TestArgb StaticFromVector4(Vector4 source) => Pack(source);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void FromVector4(ref Vector4 source) => this = Pack(source);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly Rgba32 ToRgba32() => new(this.R, this.G, this.B, this.A);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly void CopyToRgba32(ref Rgba32 destination)
     {
-        return new Vector4(this.R, this.G, this.B, this.A);
+        destination.R = this.R;
+        destination.G = this.G;
+        destination.B = this.B;
+        destination.A = this.A;
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public void CopyToVector4(ref Vector4 dest)
+    public readonly Vector4 ToVector4() => new Vector4(this.R, this.G, this.B, this.A) / MaxBytes;
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly void CopyToVector4(ref Vector4 destination) => destination = this.ToVector4();
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static TestArgb Pack(Vector4 vector)
     {
-        dest.X = this.R;
-        dest.Y = this.G;
-        dest.Z = this.B;
-        dest.W = this.A;
+        vector *= MaxBytes;
+        vector += Half;
+        vector = Numerics.Clamp(vector, Vector4.Zero, MaxBytes);
+
+        Vector128<byte> result = Vector128.ConvertToInt32(vector.AsVector128()).AsByte();
+        return new(result.GetElement(0), result.GetElement(4), result.GetElement(8), result.GetElement(12));
     }
 }
diff --git a/tests/ImageSharp.Benchmarks/General/PixelConversion/TestRgba.cs b/tests/ImageSharp.Benchmarks/General/PixelConversion/TestRgba.cs
index 76449c9d9..1499fb7d3 100644
--- a/tests/ImageSharp.Benchmarks/General/PixelConversion/TestRgba.cs
+++ b/tests/ImageSharp.Benchmarks/General/PixelConversion/TestRgba.cs
@@ -4,6 +4,7 @@
 using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Benchmarks.General.PixelConversion;
@@ -16,17 +17,29 @@ public struct TestRgba : ITestPixel<TestRgba>
     public byte B;
     public byte A;
 
+    private static readonly Vector4 MaxBytes = Vector128.Create(255f).AsVector4();
+    private static readonly Vector4 Half = Vector128.Create(.5f).AsVector4();
+
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public void FromRgba32(Rgba32 source)
+    private TestRgba(byte r, byte g, byte b, byte a)
     {
-        this = Unsafe.As<Rgba32, TestRgba>(ref source);
+        this.R = r;
+        this.G = g;
+        this.B = b;
+        this.A = a;
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public void FromRgba32(ref Rgba32 source)
-    {
-        this = Unsafe.As<Rgba32, TestRgba>(ref source);
-    }
+    private TestRgba(Rgba32 source) => this = Unsafe.As<Rgba32, TestRgba>(ref source);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void FromRgba32(Rgba32 source) => this = Unsafe.As<Rgba32, TestRgba>(ref source);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TestRgba StaticFromRgba32(Rgba32 source) => new(source);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void FromRgba32(ref Rgba32 source) => this = Unsafe.As<Rgba32, TestRgba>(ref source);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void FromBytes(byte r, byte g, byte b, byte a)
@@ -37,39 +50,35 @@ public struct TestRgba : ITestPixel<TestRgba>
         this.A = a;
     }
 
-    public void FromVector4(Vector4 source)
-    {
-        throw new System.NotImplementedException();
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void FromVector4(Vector4 source) => this = Pack(source);
 
-    public void FromVector4(ref Vector4 source)
-    {
-        throw new System.NotImplementedException();
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TestRgba StaticFromVector4(Vector4 source) => Pack(source);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public Rgba32 ToRgba32()
-    {
-        return Unsafe.As<TestRgba, Rgba32>(ref this);
-    }
+    public void FromVector4(ref Vector4 source) => this = Pack(source);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public void CopyToRgba32(ref Rgba32 dest)
-    {
-        dest = Unsafe.As<TestRgba, Rgba32>(ref this);
-    }
+    public Rgba32 ToRgba32() => Unsafe.As<TestRgba, Rgba32>(ref this);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public Vector4 ToVector4()
-    {
-        return new Vector4(this.R, this.G, this.B, this.A) * new Vector4(1f / 255f);
-    }
+    public void CopyToRgba32(ref Rgba32 destination) => destination = Unsafe.As<TestRgba, Rgba32>(ref this);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly Vector4 ToVector4() => new Vector4(this.R, this.G, this.B, this.A) / MaxBytes;
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public void CopyToVector4(ref Vector4 dest)
+    public readonly void CopyToVector4(ref Vector4 destination) => destination = this.ToVector4();
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static TestRgba Pack(Vector4 vector)
     {
-        var tmp = new Vector4(this.R, this.G, this.B, this.A);
-        tmp *= new Vector4(1f / 255f);
-        dest = tmp;
+        vector *= MaxBytes;
+        vector += Half;
+        vector = Numerics.Clamp(vector, Vector4.Zero, MaxBytes);
+
+        Vector128<byte> result = Vector128.ConvertToInt32(vector.AsVector128()).AsByte();
+        return new(result.GetElement(0), result.GetElement(4), result.GetElement(8), result.GetElement(12));
     }
 }
diff --git a/tests/ImageSharp.Benchmarks/General/PixelConversion/TestRgbaVector.cs b/tests/ImageSharp.Benchmarks/General/PixelConversion/TestRgbaVector.cs
new file mode 100644
index 000000000..07790ae99
--- /dev/null
+++ b/tests/ImageSharp.Benchmarks/General/PixelConversion/TestRgbaVector.cs
@@ -0,0 +1,51 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using SixLabors.ImageSharp.PixelFormats;
+
+namespace SixLabors.ImageSharp.Benchmarks.General.PixelConversion;
+
+[StructLayout(LayoutKind.Sequential)]
+public struct TestRgbaVector : ITestPixel<TestRgbaVector>
+{
+    private Vector4 v;
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private TestRgbaVector(Vector4 source) => this.v = source;
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void FromVector4(Vector4 source) => this.v = source;
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TestRgbaVector StaticFromVector4(Vector4 source) => new(source);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void FromVector4(ref Vector4 source) => this.v = source;
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly Vector4 ToVector4() => this.v;
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly void CopyToVector4(ref Vector4 destination) => destination = this.v;
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void FromRgba32(Rgba32 source) => this.v = source.ToScaledVector4();
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TestRgbaVector StaticFromRgba32(Rgba32 source) => new(source.ToScaledVector4());
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void FromRgba32(ref Rgba32 source) => this.v = source.ToScaledVector4();
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void FromBytes(byte r, byte g, byte b, byte a) => this.v = new Rgba32(r, g, b, a).ToScaledVector4();
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly Rgba32 ToRgba32() => Rgba32.FromScaledVector4(this.v);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly void CopyToRgba32(ref Rgba32 destination) => destination = Rgba32.FromScaledVector4(this.v);
+}
diff --git a/tests/ImageSharp.Benchmarks/Processing/BokehBlur.cs b/tests/ImageSharp.Benchmarks/Processing/BokehBlur.cs
index 58c23d2fe..82fce7dad 100644
--- a/tests/ImageSharp.Benchmarks/Processing/BokehBlur.cs
+++ b/tests/ImageSharp.Benchmarks/Processing/BokehBlur.cs
@@ -13,7 +13,7 @@ public class BokehBlur
     [Benchmark]
     public void Blur()
     {
-        using Image<Rgba32> image = new(Configuration.Default, 400, 400, Color.White);
+        using Image<Rgba32> image = new(Configuration.Default, 400, 400, Color.White.ToPixel<Rgba32>());
         image.Mutate(c => c.BokehBlur());
     }
 }
diff --git a/tests/ImageSharp.Benchmarks/Processing/Diffuse.cs b/tests/ImageSharp.Benchmarks/Processing/Diffuse.cs
index bf760aa2d..fae80fe84 100644
--- a/tests/ImageSharp.Benchmarks/Processing/Diffuse.cs
+++ b/tests/ImageSharp.Benchmarks/Processing/Diffuse.cs
@@ -13,7 +13,7 @@ public class Diffuse
     [Benchmark]
     public Size DoDiffuse()
     {
-        using Image<Rgba32> image = new(Configuration.Default, 800, 800, Color.BlanchedAlmond);
+        using Image<Rgba32> image = new(Configuration.Default, 800, 800, Color.BlanchedAlmond.ToPixel<Rgba32>());
         image.Mutate(x => x.Dither(KnownDitherings.FloydSteinberg));
 
         return image.Size;
@@ -22,7 +22,7 @@ public class Diffuse
     [Benchmark]
     public Size DoDither()
     {
-        using Image<Rgba32> image = new(Configuration.Default, 800, 800, Color.BlanchedAlmond);
+        using Image<Rgba32> image = new(Configuration.Default, 800, 800, Color.BlanchedAlmond.ToPixel<Rgba32>());
         image.Mutate(x => x.Dither());
 
         return image.Size;
diff --git a/tests/ImageSharp.Benchmarks/Processing/GaussianBlur.cs b/tests/ImageSharp.Benchmarks/Processing/GaussianBlur.cs
index 160df21e6..462d83488 100644
--- a/tests/ImageSharp.Benchmarks/Processing/GaussianBlur.cs
+++ b/tests/ImageSharp.Benchmarks/Processing/GaussianBlur.cs
@@ -13,7 +13,7 @@ public class GaussianBlur
     [Benchmark]
     public void Blur()
     {
-        using var image = new Image<Rgba32>(Configuration.Default, 400, 400, Color.White);
+        using Image<Rgba32> image = new(Configuration.Default, 400, 400, Color.White.ToPixel<Rgba32>());
         image.Mutate(c => c.GaussianBlur());
     }
 }
diff --git a/tests/ImageSharp.Benchmarks/Processing/Rotate.cs b/tests/ImageSharp.Benchmarks/Processing/Rotate.cs
index 89d2966d7..b041a9d57 100644
--- a/tests/ImageSharp.Benchmarks/Processing/Rotate.cs
+++ b/tests/ImageSharp.Benchmarks/Processing/Rotate.cs
@@ -13,7 +13,7 @@ public class Rotate
     [Benchmark]
     public Size DoRotate()
     {
-        using Image<Rgba32> image = new(Configuration.Default, 400, 400, Color.BlanchedAlmond);
+        using Image<Rgba32> image = new(Configuration.Default, 400, 400, Color.BlanchedAlmond.ToPixel<Rgba32>());
         image.Mutate(x => x.Rotate(37.5F));
 
         return image.Size;
diff --git a/tests/ImageSharp.Benchmarks/Processing/Skew.cs b/tests/ImageSharp.Benchmarks/Processing/Skew.cs
index baeff29a8..9f0103fa6 100644
--- a/tests/ImageSharp.Benchmarks/Processing/Skew.cs
+++ b/tests/ImageSharp.Benchmarks/Processing/Skew.cs
@@ -13,7 +13,7 @@ public class Skew
     [Benchmark]
     public Size DoSkew()
     {
-        using Image<Rgba32> image = new(Configuration.Default, 400, 400, Color.BlanchedAlmond);
+        using Image<Rgba32> image = new(Configuration.Default, 400, 400, Color.BlanchedAlmond.ToPixel<Rgba32>());
         image.Mutate(x => x.Skew(20, 10));
 
         return image.Size;
diff --git a/tests/ImageSharp.Tests/Color/ColorTests.CastFrom.cs b/tests/ImageSharp.Tests/Color/ColorTests.CastFrom.cs
index 4091e0cd4..2eb821b61 100644
--- a/tests/ImageSharp.Tests/Color/ColorTests.CastFrom.cs
+++ b/tests/ImageSharp.Tests/Color/ColorTests.CastFrom.cs
@@ -12,10 +12,10 @@ public partial class ColorTests
         [Fact]
         public void Rgba64()
         {
-            var source = new Rgba64(100, 2222, 3333, 4444);
+            Rgba64 source = new(100, 2222, 3333, 4444);
 
             // Act:
-            Color color = source;
+            Color color = Color.FromPixel(source);
 
             // Assert:
             Rgba64 data = color.ToPixel<Rgba64>();
@@ -25,10 +25,10 @@ public partial class ColorTests
         [Fact]
         public void Rgba32()
         {
-            var source = new Rgba32(1, 22, 33, 231);
+            Rgba32 source = new(1, 22, 33, 231);
 
             // Act:
-            Color color = source;
+            Color color = Color.FromPixel(source);
 
             // Assert:
             Rgba32 data = color.ToPixel<Rgba32>();
@@ -38,10 +38,10 @@ public partial class ColorTests
         [Fact]
         public void Argb32()
         {
-            var source = new Argb32(1, 22, 33, 231);
+            Argb32 source = new(1, 22, 33, 231);
 
             // Act:
-            Color color = source;
+            Color color = Color.FromPixel(source);
 
             // Assert:
             Argb32 data = color.ToPixel<Argb32>();
@@ -51,10 +51,10 @@ public partial class ColorTests
         [Fact]
         public void Bgra32()
         {
-            var source = new Bgra32(1, 22, 33, 231);
+            Bgra32 source = new(1, 22, 33, 231);
 
             // Act:
-            Color color = source;
+            Color color = Color.FromPixel(source);
 
             // Assert:
             Bgra32 data = color.ToPixel<Bgra32>();
@@ -64,10 +64,10 @@ public partial class ColorTests
         [Fact]
         public void Abgr32()
         {
-            var source = new Abgr32(1, 22, 33, 231);
+            Abgr32 source = new(1, 22, 33, 231);
 
             // Act:
-            Color color = source;
+            Color color = Color.FromPixel(source);
 
             // Assert:
             Abgr32 data = color.ToPixel<Abgr32>();
@@ -77,10 +77,10 @@ public partial class ColorTests
         [Fact]
         public void Rgb24()
         {
-            var source = new Rgb24(1, 22,  231);
+            Rgb24 source = new(1, 22, 231);
 
             // Act:
-            Color color = source;
+            Color color = Color.FromPixel(source);
 
             // Assert:
             Rgb24 data = color.ToPixel<Rgb24>();
@@ -90,10 +90,10 @@ public partial class ColorTests
         [Fact]
         public void Bgr24()
         {
-            var source = new Bgr24(1, 22,  231);
+            Bgr24 source = new(1, 22, 231);
 
             // Act:
-            Color color = source;
+            Color color = Color.FromPixel(source);
 
             // Assert:
             Bgr24 data = color.ToPixel<Bgr24>();
diff --git a/tests/ImageSharp.Tests/Color/ColorTests.CastTo.cs b/tests/ImageSharp.Tests/Color/ColorTests.CastTo.cs
index dacec7144..14a5a44f1 100644
--- a/tests/ImageSharp.Tests/Color/ColorTests.CastTo.cs
+++ b/tests/ImageSharp.Tests/Color/ColorTests.CastTo.cs
@@ -16,10 +16,10 @@ public partial class ColorTests
             var source = new Rgba64(100, 2222, 3333, 4444);
 
             // Act:
-            var color = new Color(source);
+            var color = Color.FromPixel(source);
 
             // Assert:
-            Rgba64 data = color;
+            Rgba64 data = color.ToPixel<Rgba64>();
             Assert.Equal(source, data);
         }
 
@@ -29,10 +29,10 @@ public partial class ColorTests
             var source = new Rgba32(1, 22, 33, 231);
 
             // Act:
-            var color = new Color(source);
+            var color = Color.FromPixel(source);
 
             // Assert:
-            Rgba32 data = color;
+            Rgba32 data = color.ToPixel<Rgba32>();
             Assert.Equal(source, data);
         }
 
@@ -42,10 +42,10 @@ public partial class ColorTests
             var source = new Argb32(1, 22, 33, 231);
 
             // Act:
-            var color = new Color(source);
+            var color = Color.FromPixel(source);
 
             // Assert:
-            Argb32 data = color;
+            Argb32 data = color.ToPixel<Argb32>();
             Assert.Equal(source, data);
         }
 
@@ -55,10 +55,10 @@ public partial class ColorTests
             var source = new Bgra32(1, 22, 33, 231);
 
             // Act:
-            var color = new Color(source);
+            var color = Color.FromPixel(source);
 
             // Assert:
-            Bgra32 data = color;
+            Bgra32 data = color.ToPixel<Bgra32>();
             Assert.Equal(source, data);
         }
 
@@ -68,10 +68,10 @@ public partial class ColorTests
             var source = new Abgr32(1, 22, 33, 231);
 
             // Act:
-            var color = new Color(source);
+            var color = Color.FromPixel(source);
 
             // Assert:
-            Abgr32 data = color;
+            Abgr32 data = color.ToPixel<Abgr32>();
             Assert.Equal(source, data);
         }
 
@@ -81,10 +81,10 @@ public partial class ColorTests
             var source = new Rgb24(1, 22, 231);
 
             // Act:
-            var color = new Color(source);
+            var color = Color.FromPixel(source);
 
             // Assert:
-            Rgb24 data = color;
+            Rgb24 data = color.ToPixel<Rgb24>();
             Assert.Equal(source, data);
         }
 
@@ -94,10 +94,10 @@ public partial class ColorTests
             var source = new Bgr24(1, 22, 231);
 
             // Act:
-            var color = new Color(source);
+            var color = Color.FromPixel(source);
 
             // Assert:
-            Bgr24 data = color;
+            Bgr24 data = color.ToPixel<Bgr24>();
             Assert.Equal(source, data);
         }
 
@@ -105,7 +105,7 @@ public partial class ColorTests
         public void Vector4Constructor()
         {
             // Act:
-            Color color = new(Vector4.One);
+            Color color = (Color)Vector4.One;
 
             // Assert:
             Assert.Equal(new RgbaVector(1, 1, 1, 1), color.ToPixel<RgbaVector>());
@@ -117,7 +117,7 @@ public partial class ColorTests
         [Fact]
         public void GenericPixelRoundTrip()
         {
-            AssertGenericPixelRoundTrip(new RgbaVector(float.Epsilon, 2 * float.Epsilon, float.MaxValue, float.MinValue));
+            AssertGenericPixelRoundTrip(new RgbaVector(0.5f, 0.75f, 1, 0));
             AssertGenericPixelRoundTrip(new Rgba64(1, 2, ushort.MaxValue, ushort.MaxValue - 1));
             AssertGenericPixelRoundTrip(new Rgb48(1, 2, ushort.MaxValue - 1));
             AssertGenericPixelRoundTrip(new La32(1, ushort.MaxValue - 1));
diff --git a/tests/ImageSharp.Tests/Color/ColorTests.ConstructFrom.cs b/tests/ImageSharp.Tests/Color/ColorTests.ConstructFrom.cs
index 3ea8623d9..9126543e5 100644
--- a/tests/ImageSharp.Tests/Color/ColorTests.ConstructFrom.cs
+++ b/tests/ImageSharp.Tests/Color/ColorTests.ConstructFrom.cs
@@ -12,10 +12,10 @@ public partial class ColorTests
         [Fact]
         public void Rgba64()
         {
-            var source = new Rgba64(100, 2222, 3333, 4444);
+            Rgba64 source = new(100, 2222, 3333, 4444);
 
             // Act:
-            var color = new Color(source);
+            Color color = Color.FromPixel(source);
 
             // Assert:
             Rgba64 data = color.ToPixel<Rgba64>();
@@ -25,10 +25,10 @@ public partial class ColorTests
         [Fact]
         public void Rgba32()
         {
-            var source = new Rgba32(1, 22, 33, 231);
+            Rgba32 source = new(1, 22, 33, 231);
 
             // Act:
-            var color = new Color(source);
+            Color color = Color.FromPixel(source);
 
             // Assert:
             Rgba32 data = color.ToPixel<Rgba32>();
@@ -38,10 +38,10 @@ public partial class ColorTests
         [Fact]
         public void Argb32()
         {
-            var source = new Argb32(1, 22, 33, 231);
+            Argb32 source = new(1, 22, 33, 231);
 
             // Act:
-            var color = new Color(source);
+            Color color = Color.FromPixel(source);
 
             // Assert:
             Argb32 data = color.ToPixel<Argb32>();
@@ -51,10 +51,10 @@ public partial class ColorTests
         [Fact]
         public void Bgra32()
         {
-            var source = new Bgra32(1, 22, 33, 231);
+            Bgra32 source = new(1, 22, 33, 231);
 
             // Act:
-            var color = new Color(source);
+            Color color = Color.FromPixel(source);
 
             // Assert:
             Bgra32 data = color.ToPixel<Bgra32>();
@@ -64,10 +64,10 @@ public partial class ColorTests
         [Fact]
         public void Abgr32()
         {
-            var source = new Abgr32(1, 22, 33, 231);
+            Abgr32 source = new(1, 22, 33, 231);
 
             // Act:
-            var color = new Color(source);
+            Color color = Color.FromPixel(source);
 
             // Assert:
             Abgr32 data = color.ToPixel<Abgr32>();
@@ -77,10 +77,10 @@ public partial class ColorTests
         [Fact]
         public void Rgb24()
         {
-            var source = new Rgb24(1, 22,  231);
+            Rgb24 source = new(1, 22, 231);
 
             // Act:
-            var color = new Color(source);
+            Color color = Color.FromPixel(source);
 
             // Assert:
             Rgb24 data = color.ToPixel<Rgb24>();
@@ -90,10 +90,10 @@ public partial class ColorTests
         [Fact]
         public void Bgr24()
         {
-            var source = new Bgr24(1, 22,  231);
+            Bgr24 source = new(1, 22, 231);
 
             // Act:
-            var color = new Color(source);
+            Color color = Color.FromPixel(source);
 
             // Assert:
             Bgr24 data = color.ToPixel<Bgr24>();
diff --git a/tests/ImageSharp.Tests/Color/ColorTests.cs b/tests/ImageSharp.Tests/Color/ColorTests.cs
index f7e209217..d430df5b4 100644
--- a/tests/ImageSharp.Tests/Color/ColorTests.cs
+++ b/tests/ImageSharp.Tests/Color/ColorTests.cs
@@ -10,12 +10,12 @@ public partial class ColorTests
     [Fact]
     public void WithAlpha()
     {
-        var c1 = Color.FromRgba(111, 222, 55, 255);
+        Color c1 = Color.FromPixel(new Rgba32(111, 222, 55, 255));
         Color c2 = c1.WithAlpha(0.5f);
 
-        var expected = new Rgba32(111, 222, 55, 128);
+        Rgba32 expected = new(111, 222, 55, 128);
 
-        Assert.Equal(expected, (Rgba32)c2);
+        Assert.Equal(expected, c2.ToPixel<Rgba32>());
     }
 
     [Theory]
@@ -23,13 +23,13 @@ public partial class ColorTests
     [InlineData(true)]
     public void Equality_WhenTrue(bool highPrecision)
     {
-        Color c1 = new Rgba64(100, 2000, 3000, 40000);
-        Color c2 = new Rgba64(100, 2000, 3000, 40000);
+        Color c1 = Color.FromPixel(new Rgba64(100, 2000, 3000, 40000));
+        Color c2 = Color.FromPixel(new Rgba64(100, 2000, 3000, 40000));
 
         if (highPrecision)
         {
-            c1 = Color.FromPixel(c1.ToPixel<RgbaVector>());
-            c2 = Color.FromPixel(c2.ToPixel<RgbaVector>());
+            c1 = Color.FromPixel(c1.ToPixel<RgbaDouble>());
+            c2 = Color.FromPixel(c2.ToPixel<RgbaDouble>());
         }
 
         Assert.True(c1.Equals(c2));
@@ -43,15 +43,15 @@ public partial class ColorTests
     [InlineData(true)]
     public void Equality_WhenFalse(bool highPrecision)
     {
-        Color c1 = new Rgba64(100, 2000, 3000, 40000);
-        Color c2 = new Rgba64(101, 2000, 3000, 40000);
-        Color c3 = new Rgba64(100, 2000, 3000, 40001);
+        Color c1 = Color.FromPixel(new Rgba64(100, 2000, 3000, 40000));
+        Color c2 = Color.FromPixel(new Rgba64(101, 2000, 3000, 40000));
+        Color c3 = Color.FromPixel(new Rgba64(100, 2000, 3000, 40001));
 
         if (highPrecision)
         {
-            c1 = Color.FromPixel(c1.ToPixel<RgbaVector>());
-            c2 = Color.FromPixel(c2.ToPixel<RgbaVector>());
-            c3 = Color.FromPixel(c3.ToPixel<RgbaVector>());
+            c1 = Color.FromPixel(c1.ToPixel<RgbaDouble>());
+            c2 = Color.FromPixel(c2.ToPixel<RgbaDouble>());
+            c3 = Color.FromPixel(c3.ToPixel<RgbaDouble>());
         }
 
         Assert.False(c1.Equals(c2));
@@ -74,7 +74,7 @@ public partial class ColorTests
 
         if (highPrecision)
         {
-            color = Color.FromPixel(color.ToPixel<RgbaVector>());
+            color = Color.FromPixel(color.ToPixel<RgbaDouble>());
         }
 
         string actual = color.ToHex();
@@ -84,22 +84,22 @@ public partial class ColorTests
     [Fact]
     public void WebSafePalette_IsCorrect()
     {
-        Rgba32[] actualPalette = Color.WebSafePalette.ToArray().Select(c => (Rgba32)c).ToArray();
+        Rgba32[] actualPalette = Color.WebSafePalette.ToArray().Select(c => c.ToPixel<Rgba32>()).ToArray();
 
         for (int i = 0; i < ReferencePalette.WebSafeColors.Length; i++)
         {
-            Assert.Equal((Rgba32)ReferencePalette.WebSafeColors[i], actualPalette[i]);
+            Assert.Equal(ReferencePalette.WebSafeColors[i].ToPixel<Rgba32>(), actualPalette[i]);
         }
     }
 
     [Fact]
     public void WernerPalette_IsCorrect()
     {
-        Rgba32[] actualPalette = Color.WernerPalette.ToArray().Select(c => (Rgba32)c).ToArray();
+        Rgba32[] actualPalette = Color.WernerPalette.ToArray().Select(c => c.ToPixel<Rgba32>()).ToArray();
 
         for (int i = 0; i < ReferencePalette.WernerColors.Length; i++)
         {
-            Assert.Equal((Rgba32)ReferencePalette.WernerColors[i], actualPalette[i]);
+            Assert.Equal(ReferencePalette.WernerColors[i].ToPixel<Rgba32>(), actualPalette[i]);
         }
     }
 
@@ -108,66 +108,48 @@ public partial class ColorTests
         [Fact]
         public void ShortHex()
         {
-            Assert.Equal(new Rgb24(255, 255, 255), (Rgb24)Color.ParseHex("#fff"));
-            Assert.Equal(new Rgb24(255, 255, 255), (Rgb24)Color.ParseHex("fff"));
-            Assert.Equal(new Rgba32(0, 0, 0, 255), (Rgba32)Color.ParseHex("000f"));
+            Assert.Equal(new Rgb24(255, 255, 255), Color.ParseHex("#fff").ToPixel<Rgb24>());
+            Assert.Equal(new Rgb24(255, 255, 255), Color.ParseHex("fff").ToPixel<Rgb24>());
+            Assert.Equal(new Rgba32(0, 0, 0, 255), Color.ParseHex("000f").ToPixel<Rgba32>());
         }
 
         [Fact]
         public void TryShortHex()
         {
             Assert.True(Color.TryParseHex("#fff", out Color actual));
-            Assert.Equal(new Rgb24(255, 255, 255), (Rgb24)actual);
+            Assert.Equal(new Rgb24(255, 255, 255), actual.ToPixel<Rgb24>());
 
             Assert.True(Color.TryParseHex("fff", out actual));
-            Assert.Equal(new Rgb24(255, 255, 255), (Rgb24)actual);
+            Assert.Equal(new Rgb24(255, 255, 255), actual.ToPixel<Rgb24>());
 
             Assert.True(Color.TryParseHex("000f", out actual));
-            Assert.Equal(new Rgba32(0, 0, 0, 255), (Rgba32)actual);
+            Assert.Equal(new Rgba32(0, 0, 0, 255), actual.ToPixel<Rgba32>());
         }
 
         [Fact]
         public void LeadingPoundIsOptional()
         {
-            Assert.Equal(new Rgb24(0, 128, 128), (Rgb24)Color.ParseHex("#008080"));
-            Assert.Equal(new Rgb24(0, 128, 128), (Rgb24)Color.ParseHex("008080"));
+            Assert.Equal(new Rgb24(0, 128, 128), Color.ParseHex("#008080").ToPixel<Rgb24>());
+            Assert.Equal(new Rgb24(0, 128, 128), Color.ParseHex("008080").ToPixel<Rgb24>());
         }
 
         [Fact]
-        public void ThrowsOnEmpty()
-        {
-            Assert.Throws<ArgumentException>(() => Color.ParseHex(string.Empty));
-        }
+        public void ThrowsOnEmpty() => Assert.Throws<ArgumentException>(() => Color.ParseHex(string.Empty));
 
         [Fact]
-        public void ThrowsOnInvalid()
-        {
-            Assert.Throws<ArgumentException>(() => Color.ParseHex("!"));
-        }
+        public void ThrowsOnInvalid() => Assert.Throws<ArgumentException>(() => Color.ParseHex("!"));
 
         [Fact]
-        public void ThrowsOnNull()
-        {
-            Assert.Throws<ArgumentNullException>(() => Color.ParseHex(null));
-        }
+        public void ThrowsOnNull() => Assert.Throws<ArgumentNullException>(() => Color.ParseHex(null));
 
         [Fact]
-        public void FalseOnEmpty()
-        {
-            Assert.False(Color.TryParseHex(string.Empty, out Color _));
-        }
+        public void FalseOnEmpty() => Assert.False(Color.TryParseHex(string.Empty, out Color _));
 
         [Fact]
-        public void FalseOnInvalid()
-        {
-            Assert.False(Color.TryParseHex("!", out Color _));
-        }
+        public void FalseOnInvalid() => Assert.False(Color.TryParseHex("!", out Color _));
 
         [Fact]
-        public void FalseOnNull()
-        {
-            Assert.False(Color.TryParseHex(null, out Color _));
-        }
+        public void FalseOnNull() => Assert.False(Color.TryParseHex(null, out Color _));
     }
 
     public class FromString
@@ -177,10 +159,10 @@ public partial class ColorTests
         {
             foreach (string name in ReferencePalette.ColorNames.Keys)
             {
-                Rgba32 expected = ReferencePalette.ColorNames[name];
-                Assert.Equal(expected, (Rgba32)Color.Parse(name));
-                Assert.Equal(expected, (Rgba32)Color.Parse(name.ToLowerInvariant()));
-                Assert.Equal(expected, (Rgba32)Color.Parse(expected.ToHex()));
+                Rgba32 expected = ReferencePalette.ColorNames[name].ToPixel<Rgba32>();
+                Assert.Equal(expected, Color.Parse(name).ToPixel<Rgba32>());
+                Assert.Equal(expected, Color.Parse(name.ToLowerInvariant()).ToPixel<Rgba32>());
+                Assert.Equal(expected, Color.Parse(expected.ToHex()).ToPixel<Rgba32>());
             }
         }
 
@@ -189,53 +171,35 @@ public partial class ColorTests
         {
             foreach (string name in ReferencePalette.ColorNames.Keys)
             {
-                Rgba32 expected = ReferencePalette.ColorNames[name];
+                Rgba32 expected = ReferencePalette.ColorNames[name].ToPixel<Rgba32>();
 
                 Assert.True(Color.TryParse(name, out Color actual));
-                Assert.Equal(expected, (Rgba32)actual);
+                Assert.Equal(expected, actual.ToPixel<Rgba32>());
 
                 Assert.True(Color.TryParse(name.ToLowerInvariant(), out actual));
-                Assert.Equal(expected, (Rgba32)actual);
+                Assert.Equal(expected, actual.ToPixel<Rgba32>());
 
                 Assert.True(Color.TryParse(expected.ToHex(), out actual));
-                Assert.Equal(expected, (Rgba32)actual);
+                Assert.Equal(expected, actual.ToPixel<Rgba32>());
             }
         }
 
         [Fact]
-        public void ThrowsOnEmpty()
-        {
-            Assert.Throws<ArgumentException>(() => Color.Parse(string.Empty));
-        }
+        public void ThrowsOnEmpty() => Assert.Throws<ArgumentException>(() => Color.Parse(string.Empty));
 
         [Fact]
-        public void ThrowsOnInvalid()
-        {
-            Assert.Throws<ArgumentException>(() => Color.Parse("!"));
-        }
+        public void ThrowsOnInvalid() => Assert.Throws<ArgumentException>(() => Color.Parse("!"));
 
         [Fact]
-        public void ThrowsOnNull()
-        {
-            Assert.Throws<ArgumentNullException>(() => Color.Parse(null));
-        }
+        public void ThrowsOnNull() => Assert.Throws<ArgumentNullException>(() => Color.Parse(null));
 
         [Fact]
-        public void FalseOnEmpty()
-        {
-            Assert.False(Color.TryParse(string.Empty, out Color _));
-        }
+        public void FalseOnEmpty() => Assert.False(Color.TryParse(string.Empty, out Color _));
 
         [Fact]
-        public void FalseOnInvalid()
-        {
-            Assert.False(Color.TryParse("!", out Color _));
-        }
+        public void FalseOnInvalid() => Assert.False(Color.TryParse("!", out Color _));
 
         [Fact]
-        public void FalseOnNull()
-        {
-            Assert.False(Color.TryParse(null, out Color _));
-        }
+        public void FalseOnNull() => Assert.False(Color.TryParse(null, out Color _));
     }
 }
diff --git a/tests/ImageSharp.Tests/Color/RgbaDouble.cs b/tests/ImageSharp.Tests/Color/RgbaDouble.cs
new file mode 100644
index 000000000..9a751e879
--- /dev/null
+++ b/tests/ImageSharp.Tests/Color/RgbaDouble.cs
@@ -0,0 +1,189 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using SixLabors.ImageSharp.PixelFormats;
+
+namespace SixLabors.ImageSharp.Tests;
+
+/// <summary>
+/// Unpacked pixel type containing four 64-bit floating-point values typically ranging from 0 to 1.
+/// The color components are stored in red, green, blue, and alpha order.
+/// <para>
+/// Ranges from [0, 0, 0, 0] to [1, 1, 1, 1] in vector form.
+/// </para>
+/// </summary>
+/// <remarks>
+/// This struct is fully mutable. This is done (against the guidelines) for the sake of performance,
+/// as it avoids the need to create new values for modification operations.
+/// </remarks>
+[StructLayout(LayoutKind.Sequential)]
+public struct RgbaDouble : IPixel<RgbaDouble>
+{
+    /// <summary>
+    /// Gets or sets the red component.
+    /// </summary>
+    public double R;
+
+    /// <summary>
+    /// Gets or sets the green component.
+    /// </summary>
+    public double G;
+
+    /// <summary>
+    /// Gets or sets the blue component.
+    /// </summary>
+    public double B;
+
+    /// <summary>
+    /// Gets or sets the alpha component.
+    /// </summary>
+    public double A;
+
+    private const float MaxBytes = byte.MaxValue;
+    private static readonly Vector4 Max = new(MaxBytes);
+    private static readonly Vector4 Half = new(0.5F);
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="RgbaVector"/> struct.
+    /// </summary>
+    /// <param name="r">The red component.</param>
+    /// <param name="g">The green component.</param>
+    /// <param name="b">The blue component.</param>
+    /// <param name="a">The alpha component.</param>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public RgbaDouble(double r, double g, double b, double a = 1)
+    {
+        this.R = r;
+        this.G = g;
+        this.B = b;
+        this.A = a;
+    }
+
+    /// <summary>
+    /// Compares two <see cref="RgbaDouble"/> objects for equality.
+    /// </summary>
+    /// <param name="left">The <see cref="RgbaDouble"/> on the left side of the operand.</param>
+    /// <param name="right">The <see cref="RgbaDouble"/> on the right side of the operand.</param>
+    /// <returns>
+    /// True if the <paramref name="left"/> parameter is equal to the <paramref name="right"/> parameter; otherwise, false.
+    /// </returns>
+    [MethodImpl(InliningOptions.ShortMethod)]
+    public static bool operator ==(RgbaDouble left, RgbaDouble right) => left.Equals(right);
+
+    /// <summary>
+    /// Compares two <see cref="RgbaDouble"/> objects for equality.
+    /// </summary>
+    /// <param name="left">The <see cref="RgbaDouble"/> on the left side of the operand.</param>
+    /// <param name="right">The <see cref="RgbaDouble"/> on the right side of the operand.</param>
+    /// <returns>
+    /// True if the <paramref name="left"/> parameter is not equal to the <paramref name="right"/> parameter; otherwise, false.
+    /// </returns>
+    [MethodImpl(InliningOptions.ShortMethod)]
+    public static bool operator !=(RgbaDouble left, RgbaDouble right) => !left.Equals(right);
+
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly Rgba32 ToRgba32() => Rgba32.FromScaledVector4(this.ToScaledVector4());
+
+    /// <inheritdoc/>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly Vector4 ToScaledVector4() => this.ToVector4();
+
+    /// <inheritdoc/>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly Vector4 ToVector4() => new((float)this.R, (float)this.G, (float)this.B, (float)this.A);
+
+    /// <inheritdoc />
+    public static PixelTypeInfo GetPixelTypeInfo()
+        => PixelTypeInfo.Create<RgbaDouble>(
+            PixelComponentInfo.Create<RgbaDouble>(4, 64, 64, 64, 64),
+            PixelColorType.RGB | PixelColorType.Alpha,
+            PixelAlphaRepresentation.Unassociated);
+
+    /// <inheritdoc />
+    public static PixelOperations<RgbaDouble> CreatePixelOperations() => new();
+
+    /// <inheritdoc/>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static RgbaDouble FromScaledVector4(Vector4 source) => FromVector4(source);
+
+    /// <inheritdoc/>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static RgbaDouble FromVector4(Vector4 source)
+    {
+        source = Numerics.Clamp(source, Vector4.Zero, Vector4.One);
+        return new(source.X, source.Y, source.Z, source.W);
+    }
+
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static RgbaDouble FromAbgr32(Abgr32 source) => FromScaledVector4(source.ToScaledVector4());
+
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static RgbaDouble FromArgb32(Argb32 source) => FromScaledVector4(source.ToScaledVector4());
+
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static RgbaDouble FromBgra5551(Bgra5551 source) => FromScaledVector4(source.ToScaledVector4());
+
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static RgbaDouble FromBgr24(Bgr24 source) => FromScaledVector4(source.ToScaledVector4());
+
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static RgbaDouble FromBgra32(Bgra32 source) => FromScaledVector4(source.ToScaledVector4());
+
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static RgbaDouble FromL8(L8 source) => FromScaledVector4(source.ToScaledVector4());
+
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static RgbaDouble FromL16(L16 source) => FromScaledVector4(source.ToScaledVector4());
+
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static RgbaDouble FromLa16(La16 source) => FromScaledVector4(source.ToScaledVector4());
+
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static RgbaDouble FromLa32(La32 source) => FromScaledVector4(source.ToScaledVector4());
+
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static RgbaDouble FromRgb24(Rgb24 source) => FromScaledVector4(source.ToScaledVector4());
+
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static RgbaDouble FromRgba32(Rgba32 source) => FromScaledVector4(source.ToScaledVector4());
+
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static RgbaDouble FromRgb48(Rgb48 source) => FromScaledVector4(source.ToScaledVector4());
+
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static RgbaDouble FromRgba64(Rgba64 source) => FromScaledVector4(source.ToScaledVector4());
+
+    /// <inheritdoc/>
+    public override readonly bool Equals(object obj) => obj is RgbaDouble other && this.Equals(other);
+
+    /// <inheritdoc/>
+    [MethodImpl(InliningOptions.ShortMethod)]
+    public readonly bool Equals(RgbaDouble other) =>
+        this.R.Equals(other.R)
+        && this.G.Equals(other.G)
+        && this.B.Equals(other.B)
+        && this.A.Equals(other.A);
+
+    /// <inheritdoc/>
+    public override readonly string ToString() => FormattableString.Invariant($"RgbaDouble({this.R:#0.##}, {this.G:#0.##}, {this.B:#0.##}, {this.A:#0.##})");
+
+    /// <inheritdoc/>
+    public override readonly int GetHashCode() => HashCode.Combine(this.R, this.G, this.B, this.A);
+}
diff --git a/tests/ImageSharp.Tests/Common/SimdUtilsTests.cs b/tests/ImageSharp.Tests/Common/SimdUtilsTests.cs
index 3e8e17164..c81eaea63 100644
--- a/tests/ImageSharp.Tests/Common/SimdUtilsTests.cs
+++ b/tests/ImageSharp.Tests/Common/SimdUtilsTests.cs
@@ -26,7 +26,7 @@ public partial class SimdUtilsTests
     [InlineData(5.3, 536.4, 4.5, 8.1)]
     public void PseudoRound(float x, float y, float z, float w)
     {
-        var v = new Vector4(x, y, z, w);
+        Vector4 v = new(x, y, z, w);
 
         Vector4 actual = v.PseudoRound();
 
@@ -57,7 +57,7 @@ public partial class SimdUtilsTests
     {
         float[] data = new float[Vector<float>.Count];
 
-        var rnd = new Random(seed);
+        Random rnd = new(seed);
 
         for (int i = 0; i < Vector<float>.Count; i++)
         {
@@ -185,10 +185,10 @@ public partial class SimdUtilsTests
         short[] sData = new Random(scale).GenerateRandomInt16Array(2 * n, (short)-scale, scale);
         float[] fData = sData.Select(u => (float)u).ToArray();
 
-        var source = new Vector<short>(sData);
+        Vector<short> source = new(sData);
 
-        var expected1 = new Vector<float>(fData, 0);
-        var expected2 = new Vector<float>(fData, n);
+        Vector<float> expected1 = new(fData, 0);
+        Vector<float> expected2 = new(fData, n);
 
         // Act:
         SimdUtils.ExtendedIntrinsics.ConvertToSingle(source, out Vector<float> actual1, out Vector<float> actual2);
@@ -262,7 +262,7 @@ public partial class SimdUtilsTests
         byte[] g = Enumerable.Range(100, 32).Select(x => (byte)x).ToArray();
         byte[] b = Enumerable.Range(200, 32).Select(x => (byte)x).ToArray();
         const int padding = 4;
-        var d = new Rgb24[32 + padding];
+        Rgb24[] d = new Rgb24[32 + padding];
 
         ReadOnlySpan<byte> rr = r.AsSpan();
         ReadOnlySpan<byte> gg = g.AsSpan();
@@ -296,7 +296,7 @@ public partial class SimdUtilsTests
         byte[] g = Enumerable.Range(100, 32).Select(x => (byte)x).ToArray();
         byte[] b = Enumerable.Range(200, 32).Select(x => (byte)x).ToArray();
 
-        var d = new Rgba32[32];
+        Rgba32[] d = new Rgba32[32];
 
         ReadOnlySpan<byte> rr = r.AsSpan();
         ReadOnlySpan<byte> gg = g.AsSpan();
@@ -322,18 +322,18 @@ public partial class SimdUtilsTests
     internal static void TestPackFromRgbPlanes<TPixel>(int count, Action<byte[], byte[], byte[], TPixel[]> packMethod)
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        var rnd = new Random(42);
+        Random rnd = new(42);
         byte[] r = rnd.GenerateRandomByteArray(count);
         byte[] g = rnd.GenerateRandomByteArray(count);
         byte[] b = rnd.GenerateRandomByteArray(count);
 
-        var expected = new TPixel[count];
+        TPixel[] expected = new TPixel[count];
         for (int i = 0; i < count; i++)
         {
-            expected[i].FromRgb24(new Rgb24(r[i], g[i], b[i]));
+            expected[i] = TPixel.FromRgb24(new Rgb24(r[i], g[i], b[i]));
         }
 
-        var actual = new TPixel[count + 3]; // padding for Rgb24 AVX2
+        TPixel[] actual = new TPixel[count + 3]; // padding for Rgb24 AVX2
         packMethod(r, g, b, actual);
 
         Assert.True(expected.AsSpan().SequenceEqual(actual.AsSpan()[..count]));
diff --git a/tests/ImageSharp.Tests/Drawing/DrawImageTests.cs b/tests/ImageSharp.Tests/Drawing/DrawImageTests.cs
index 533f0c6de..88f4cde7a 100644
--- a/tests/ImageSharp.Tests/Drawing/DrawImageTests.cs
+++ b/tests/ImageSharp.Tests/Drawing/DrawImageTests.cs
@@ -119,7 +119,7 @@ public class DrawImageTests
     public void WorksWithDifferentLocations(TestImageProvider<Rgba32> provider, int x, int y)
     {
         using Image<Rgba32> background = provider.GetImage();
-        using Image<Rgba32> overlay = new(50, 50, Color.Black.ToRgba32());
+        using Image<Rgba32> overlay = new(50, 50, Color.Black.ToPixel<Rgba32>());
 
         background.Mutate(c => c.DrawImage(overlay, new Point(x, y), PixelColorBlendingMode.Normal, 1F));
 
@@ -144,7 +144,7 @@ public class DrawImageTests
     public void WorksWithDifferentBounds(TestImageProvider<Rgba32> provider, int width, int height)
     {
         using Image<Rgba32> background = provider.GetImage();
-        using Image<Rgba32> overlay = new(50, 50, Color.Black.ToRgba32());
+        using Image<Rgba32> overlay = new(50, 50, Color.Black.ToPixel<Rgba32>());
 
         background.Mutate(c => c.DrawImage(overlay, new Rectangle(0, 0, width, height), PixelColorBlendingMode.Normal, 1F));
 
diff --git a/tests/ImageSharp.Tests/Formats/Bmp/BmpDecoderTests.cs b/tests/ImageSharp.Tests/Formats/Bmp/BmpDecoderTests.cs
index e76f21d0e..78a7b2c11 100644
--- a/tests/ImageSharp.Tests/Formats/Bmp/BmpDecoderTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Bmp/BmpDecoderTests.cs
@@ -477,7 +477,7 @@ public class BmpDecoderTests
         using MemoryStream stream = new(testFile.Bytes, false);
         ImageInfo imageInfo = Image.Identify(stream);
         Assert.NotNull(imageInfo);
-        Assert.Equal(expectedPixelSize, imageInfo.PixelType?.BitsPerPixel);
+        Assert.Equal(expectedPixelSize, imageInfo.PixelType.BitsPerPixel);
     }
 
     [Theory]
diff --git a/tests/ImageSharp.Tests/Formats/Jpg/Utils/LibJpegTools.ComponentData.cs b/tests/ImageSharp.Tests/Formats/Jpg/Utils/LibJpegTools.ComponentData.cs
index 80365b472..65d0a01ff 100644
--- a/tests/ImageSharp.Tests/Formats/Jpg/Utils/LibJpegTools.ComponentData.cs
+++ b/tests/ImageSharp.Tests/Formats/Jpg/Utils/LibJpegTools.ComponentData.cs
@@ -42,7 +42,7 @@ internal static partial class LibJpegTools
 
         public int QuantizationTableIndex => throw new NotSupportedException();
 
-        public Buffer2D<Block8x8> SpectralBlocks { get; private set; }
+        public Buffer2D<Block8x8> SpectralBlocks { get; }
 
         public short MinVal { get; private set; } = short.MaxValue;
 
@@ -102,7 +102,7 @@ internal static partial class LibJpegTools
 
         public static ComponentData Load(JpegComponent c, int index)
         {
-            var result = new ComponentData(
+            ComponentData result = new(
                 c.WidthInBlocks,
                 c.HeightInBlocks,
                 index);
@@ -113,7 +113,7 @@ internal static partial class LibJpegTools
 
         public Image<Rgba32> CreateGrayScaleImage()
         {
-            var result = new Image<Rgba32>(this.WidthInBlocks * 8, this.HeightInBlocks * 8);
+            Image<Rgba32> result = new(this.WidthInBlocks * 8, this.HeightInBlocks * 8);
 
             for (int by = 0; by < this.HeightInBlocks; by++)
             {
@@ -136,9 +136,8 @@ internal static partial class LibJpegTools
                 {
                     float val = this.GetBlockValue(block, x, y);
 
-                    var v = new Vector4(val, val, val, 1);
-                    Rgba32 color = default;
-                    color.FromVector4(v);
+                    Vector4 v = new(val, val, val, 1);
+                    Rgba32 color = Rgba32.FromVector4(v);
 
                     int yy = (by * 8) + y;
                     int xx = (bx * 8) + x;
@@ -198,7 +197,7 @@ internal static partial class LibJpegTools
                 return false;
             }
 
-            if (object.ReferenceEquals(this, obj))
+            if (ReferenceEquals(this, obj))
             {
                 return true;
             }
diff --git a/tests/ImageSharp.Tests/Formats/Jpg/Utils/LibJpegTools.SpectralData.cs b/tests/ImageSharp.Tests/Formats/Jpg/Utils/LibJpegTools.SpectralData.cs
index a4bb6b7bf..9eec547a3 100644
--- a/tests/ImageSharp.Tests/Formats/Jpg/Utils/LibJpegTools.SpectralData.cs
+++ b/tests/ImageSharp.Tests/Formats/Jpg/Utils/LibJpegTools.SpectralData.cs
@@ -14,11 +14,11 @@ internal static partial class LibJpegTools
     /// </summary>
     public class SpectralData : IEquatable<SpectralData>
     {
-        public int ComponentCount { get; private set; }
+        public int ComponentCount { get; }
 
-        public LibJpegTools.ComponentData[] Components { get; private set; }
+        public ComponentData[] Components { get; }
 
-        internal SpectralData(LibJpegTools.ComponentData[] components)
+        internal SpectralData(ComponentData[] components)
         {
             this.ComponentCount = components.Length;
             this.Components = components;
@@ -31,16 +31,16 @@ internal static partial class LibJpegTools
                 return null;
             }
 
-            LibJpegTools.ComponentData c0 = this.Components[0];
-            LibJpegTools.ComponentData c1 = this.Components[1];
-            LibJpegTools.ComponentData c2 = this.Components[2];
+            ComponentData c0 = this.Components[0];
+            ComponentData c1 = this.Components[1];
+            ComponentData c2 = this.Components[2];
 
             if (c0.Size != c1.Size || c1.Size != c2.Size)
             {
                 return null;
             }
 
-            var result = new Image<Rgba32>(c0.WidthInBlocks * 8, c0.HeightInBlocks * 8);
+            Image<Rgba32> result = new(c0.WidthInBlocks * 8, c0.HeightInBlocks * 8);
 
             for (int by = 0; by < c0.HeightInBlocks; by++)
             {
@@ -55,18 +55,14 @@ internal static partial class LibJpegTools
 
         internal void WriteToImage(int bx, int by, Image<Rgba32> image)
         {
-            LibJpegTools.ComponentData c0 = this.Components[0];
-            LibJpegTools.ComponentData c1 = this.Components[1];
-            LibJpegTools.ComponentData c2 = this.Components[2];
+            ComponentData c0 = this.Components[0];
+            ComponentData c1 = this.Components[1];
+            ComponentData c2 = this.Components[2];
 
             Block8x8 block0 = c0.SpectralBlocks[bx, by];
             Block8x8 block1 = c1.SpectralBlocks[bx, by];
             Block8x8 block2 = c2.SpectralBlocks[bx, by];
 
-            float d0 = c0.MaxVal - c0.MinVal;
-            float d1 = c1.MaxVal - c1.MinVal;
-            float d2 = c2.MaxVal - c2.MinVal;
-
             for (int y = 0; y < 8; y++)
             {
                 for (int x = 0; x < 8; x++)
@@ -75,9 +71,8 @@ internal static partial class LibJpegTools
                     float val1 = c0.GetBlockValue(block1, x, y);
                     float val2 = c0.GetBlockValue(block2, x, y);
 
-                    var v = new Vector4(val0, val1, val2, 1);
-                    Rgba32 color = default;
-                    color.FromVector4(v);
+                    Vector4 v = new(val0, val1, val2, 1);
+                    Rgba32 color = Rgba32.FromVector4(v);
 
                     int yy = (by * 8) + y;
                     int xx = (bx * 8) + x;
@@ -105,8 +100,8 @@ internal static partial class LibJpegTools
 
             for (int i = 0; i < this.ComponentCount; i++)
             {
-                LibJpegTools.ComponentData a = this.Components[i];
-                LibJpegTools.ComponentData b = other.Components[i];
+                ComponentData a = this.Components[i];
+                ComponentData b = other.Components[i];
                 if (!a.Equals(b))
                 {
                     return false;
@@ -116,10 +111,7 @@ internal static partial class LibJpegTools
             return true;
         }
 
-        public override bool Equals(object obj)
-        {
-            return obj is SpectralData other && this.Equals(other);
-        }
+        public override bool Equals(object obj) => obj is SpectralData other && this.Equals(other);
 
         public override int GetHashCode()
         {
@@ -139,9 +131,6 @@ internal static partial class LibJpegTools
             return left.Equals(right);
         }
 
-        public static bool operator !=(SpectralData left, SpectralData right)
-        {
-            return !(left == right);
-        }
+        public static bool operator !=(SpectralData left, SpectralData right) => !(left == right);
     }
 }
diff --git a/tests/ImageSharp.Tests/Formats/Png/PngDecoderTests.cs b/tests/ImageSharp.Tests/Formats/Png/PngDecoderTests.cs
index bc277bf48..800b1fb4b 100644
--- a/tests/ImageSharp.Tests/Formats/Png/PngDecoderTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Png/PngDecoderTests.cs
@@ -581,7 +581,7 @@ public partial class PngDecoderTests
         using Image<TPixel> image = provider.GetImage(PngDecoder.Instance);
         PngMetadata metadata = image.Metadata.GetPngMetadata();
         Assert.NotNull(metadata.ColorTable);
-        Assert.Contains(metadata.ColorTable.Value.ToArray(), x => x.ToRgba32().A < 255);
+        Assert.Contains(metadata.ColorTable.Value.ToArray(), x => x.ToPixel<Rgba32>().A < 255);
     }
 
     // https://github.com/SixLabors/ImageSharp/issues/2209
@@ -594,7 +594,7 @@ public partial class PngDecoderTests
         ImageInfo imageInfo = Image.Identify(stream);
         PngMetadata metadata = imageInfo.Metadata.GetPngMetadata();
         Assert.NotNull(metadata.ColorTable);
-        Assert.Contains(metadata.ColorTable.Value.ToArray(), x => x.ToRgba32().A < 255);
+        Assert.Contains(metadata.ColorTable.Value.ToArray(), x => x.ToPixel<Rgba32>().A < 255);
     }
 
     // https://github.com/SixLabors/ImageSharp/issues/410
diff --git a/tests/ImageSharp.Tests/Formats/Png/PngEncoderTests.cs b/tests/ImageSharp.Tests/Formats/Png/PngEncoderTests.cs
index e70854b08..0fdd49630 100644
--- a/tests/ImageSharp.Tests/Formats/Png/PngEncoderTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Png/PngEncoderTests.cs
@@ -256,21 +256,21 @@ public partial class PngEncoderTests
     [Theory]
     [WithBlankImages(1, 1, PixelTypes.A8, PngColorType.GrayscaleWithAlpha, PngBitDepth.Bit8)]
     [WithBlankImages(1, 1, PixelTypes.Argb32, PngColorType.RgbWithAlpha, PngBitDepth.Bit8)]
-    [WithBlankImages(1, 1, PixelTypes.Bgr565, PngColorType.RgbWithAlpha, PngBitDepth.Bit8)]
+    [WithBlankImages(1, 1, PixelTypes.Bgr565, PngColorType.Rgb, PngBitDepth.Bit8)]
     [WithBlankImages(1, 1, PixelTypes.Bgra4444, PngColorType.RgbWithAlpha, PngBitDepth.Bit8)]
     [WithBlankImages(1, 1, PixelTypes.Byte4, PngColorType.RgbWithAlpha, PngBitDepth.Bit8)]
-    [WithBlankImages(1, 1, PixelTypes.HalfSingle, PngColorType.RgbWithAlpha, PngBitDepth.Bit8)]
-    [WithBlankImages(1, 1, PixelTypes.HalfVector2, PngColorType.RgbWithAlpha, PngBitDepth.Bit8)]
-    [WithBlankImages(1, 1, PixelTypes.HalfVector4, PngColorType.RgbWithAlpha, PngBitDepth.Bit8)]
-    [WithBlankImages(1, 1, PixelTypes.NormalizedByte2, PngColorType.RgbWithAlpha, PngBitDepth.Bit8)]
+    [WithBlankImages(1, 1, PixelTypes.HalfSingle, PngColorType.Rgb, PngBitDepth.Bit16)]
+    [WithBlankImages(1, 1, PixelTypes.HalfVector2, PngColorType.Rgb, PngBitDepth.Bit16)]
+    [WithBlankImages(1, 1, PixelTypes.HalfVector4, PngColorType.RgbWithAlpha, PngBitDepth.Bit16)]
+    [WithBlankImages(1, 1, PixelTypes.NormalizedByte2, PngColorType.Rgb, PngBitDepth.Bit8)]
     [WithBlankImages(1, 1, PixelTypes.NormalizedByte4, PngColorType.RgbWithAlpha, PngBitDepth.Bit8)]
-    [WithBlankImages(1, 1, PixelTypes.NormalizedShort4, PngColorType.RgbWithAlpha, PngBitDepth.Bit8)]
-    [WithBlankImages(1, 1, PixelTypes.Rg32, PngColorType.RgbWithAlpha, PngBitDepth.Bit8)]
-    [WithBlankImages(1, 1, PixelTypes.Rgba1010102, PngColorType.RgbWithAlpha, PngBitDepth.Bit8)]
+    [WithBlankImages(1, 1, PixelTypes.NormalizedShort4, PngColorType.RgbWithAlpha, PngBitDepth.Bit16)]
+    [WithBlankImages(1, 1, PixelTypes.Rg32, PngColorType.Rgb, PngBitDepth.Bit16)]
+    [WithBlankImages(1, 1, PixelTypes.Rgba1010102, PngColorType.RgbWithAlpha, PngBitDepth.Bit16)]
     [WithBlankImages(1, 1, PixelTypes.Rgba32, PngColorType.RgbWithAlpha, PngBitDepth.Bit8)]
     [WithBlankImages(1, 1, PixelTypes.RgbaVector, PngColorType.RgbWithAlpha, PngBitDepth.Bit16)]
-    [WithBlankImages(1, 1, PixelTypes.Short2, PngColorType.RgbWithAlpha, PngBitDepth.Bit8)]
-    [WithBlankImages(1, 1, PixelTypes.Short4, PngColorType.RgbWithAlpha, PngBitDepth.Bit8)]
+    [WithBlankImages(1, 1, PixelTypes.Short2, PngColorType.Rgb, PngBitDepth.Bit16)]
+    [WithBlankImages(1, 1, PixelTypes.Short4, PngColorType.RgbWithAlpha, PngBitDepth.Bit16)]
     [WithBlankImages(1, 1, PixelTypes.Rgb24, PngColorType.Rgb, PngBitDepth.Bit8)]
     [WithBlankImages(1, 1, PixelTypes.Bgr24, PngColorType.Rgb, PngBitDepth.Bit8)]
     [WithBlankImages(1, 1, PixelTypes.Bgra32, PngColorType.RgbWithAlpha, PngBitDepth.Bit8)]
@@ -391,7 +391,7 @@ public partial class PngEncoderTests
             TransparentColorMode = PngTransparentColorMode.Clear,
             ColorType = colorType
         };
-        Rgba32 rgba32 = Color.Blue;
+        Rgba32 rgba32 = Color.Blue.ToPixel<Rgba32>();
         image.ProcessPixelRows(accessor =>
         {
             for (int y = 0; y < image.Height; y++)
@@ -406,7 +406,7 @@ public partial class PngEncoderTests
 
                 for (int x = 0; x < image.Width; x++)
                 {
-                    rowSpan[x].FromRgba32(rgba32);
+                    rowSpan[x] = Rgba32.FromRgba32(rgba32);
                 }
             }
         });
@@ -418,7 +418,7 @@ public partial class PngEncoderTests
         // assert
         memStream.Position = 0;
         using Image<Rgba32> actual = Image.Load<Rgba32>(memStream);
-        Rgba32 expectedColor = Color.Blue;
+        Rgba32 expectedColor = Color.Blue.ToPixel<Rgba32>();
         if (colorType is PngColorType.Grayscale or PngColorType.GrayscaleWithAlpha)
         {
             byte luminance = ColorNumerics.Get8BitBT709Luminance(expectedColor.R, expectedColor.G, expectedColor.B);
@@ -427,13 +427,14 @@ public partial class PngEncoderTests
 
         actual.ProcessPixelRows(accessor =>
         {
+            Rgba32 transparent = Color.Transparent.ToPixel<Rgba32>();
             for (int y = 0; y < accessor.Height; y++)
             {
                 Span<Rgba32> rowSpan = accessor.GetRowSpan(y);
 
                 if (y > 25)
                 {
-                    expectedColor = Color.Transparent;
+                    expectedColor = transparent;
                 }
 
                 for (int x = 0; x < accessor.Width; x++)
diff --git a/tests/ImageSharp.Tests/Formats/Tga/TgaDecoderTests.cs b/tests/ImageSharp.Tests/Formats/Tga/TgaDecoderTests.cs
index da5de8e89..dbd7885e5 100644
--- a/tests/ImageSharp.Tests/Formats/Tga/TgaDecoderTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Tga/TgaDecoderTests.cs
@@ -1,7 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics.X86;
 using Microsoft.DotNet.RemoteExecutor;
 using SixLabors.ImageSharp.Formats;
@@ -724,10 +723,8 @@ public class TgaDecoderTests
     {
         using (Image<TPixel> image = provider.GetImage(TgaDecoder.Instance))
         {
-            // Using here the reference output instead of the the reference decoder,
-            // because the reference decoder does not ignore the alpha data here.
             image.DebugSave(provider);
-            image.CompareToReferenceOutput(ImageComparer.Exact, provider);
+            ImageComparingUtils.CompareWithReferenceDecoder(provider, image);
         }
     }
 
@@ -771,6 +768,19 @@ public class TgaDecoderTests
             appendPixelTypeToFileName: false);
     }
 
+    // https://github.com/SixLabors/ImageSharp/issues/2629
+    [Theory]
+    [WithFile(Issue2629, PixelTypes.Rgba32)]
+    public void TgaDecoder_CanDecode_Issue2629<TPixel>(TestImageProvider<TPixel> provider)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        using (Image<TPixel> image = provider.GetImage(TgaDecoder.Instance))
+        {
+            image.DebugSave(provider);
+            ImageComparingUtils.CompareWithReferenceDecoder(provider, image);
+        }
+    }
+
     [Theory]
     [WithFile(Bit16BottomLeft, PixelTypes.Rgba32)]
     [WithFile(Bit24BottomLeft, PixelTypes.Rgba32)]
diff --git a/tests/ImageSharp.Tests/Formats/Tiff/BigTiffDecoderTests.cs b/tests/ImageSharp.Tests/Formats/Tiff/BigTiffDecoderTests.cs
index 8e90b1dd5..72f53cab7 100644
--- a/tests/ImageSharp.Tests/Formats/Tiff/BigTiffDecoderTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Tiff/BigTiffDecoderTests.cs
@@ -65,7 +65,7 @@ public class BigTiffDecoderTests : TiffDecoderBaseTester
         using MemoryStream stream = new(testFile.Bytes, false);
         ImageInfo info = Image.Identify(stream);
 
-        Assert.Equal(expectedPixelSize, info.PixelType?.BitsPerPixel);
+        Assert.Equal(expectedPixelSize, info.PixelType.BitsPerPixel);
         Assert.Equal(expectedWidth, info.Width);
         Assert.Equal(expectedHeight, info.Height);
         Assert.NotNull(info.Metadata);
diff --git a/tests/ImageSharp.Tests/Formats/Tiff/PhotometricInterpretation/PhotometricInterpretationTestBase.cs b/tests/ImageSharp.Tests/Formats/Tiff/PhotometricInterpretation/PhotometricInterpretationTestBase.cs
index b17440383..3582dc75a 100644
--- a/tests/ImageSharp.Tests/Formats/Tiff/PhotometricInterpretation/PhotometricInterpretationTestBase.cs
+++ b/tests/ImageSharp.Tests/Formats/Tiff/PhotometricInterpretation/PhotometricInterpretationTestBase.cs
@@ -47,7 +47,7 @@ public abstract class PhotometricInterpretationTestBase
 
         using (var image = new Image<Rgba32>(resultWidth, resultHeight))
         {
-            image.Mutate(x => x.BackgroundColor(DefaultColor));
+            image.Mutate(x => x.BackgroundColor(Color.FromPixel(DefaultColor)));
             Buffer2D<Rgba32> pixels = image.GetRootFramePixelBuffer();
 
             decodeAction(pixels);
diff --git a/tests/ImageSharp.Tests/Formats/Tiff/TiffEncoderMultiframeTests.cs b/tests/ImageSharp.Tests/Formats/Tiff/TiffEncoderMultiframeTests.cs
index b74093fcc..dce6ebc38 100644
--- a/tests/ImageSharp.Tests/Formats/Tiff/TiffEncoderMultiframeTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Tiff/TiffEncoderMultiframeTests.cs
@@ -70,9 +70,9 @@ public class TiffEncoderMultiframeTests : TiffEncoderBaseTester
         using Image<TPixel> image = provider.GetImage();
         Assert.Equal(1, image.Frames.Count);
 
-        using var image1 = new Image<Rgba32>(image.Width, image.Height, Color.Green.ToRgba32());
+        using var image1 = new Image<Rgba32>(image.Width, image.Height, Color.Green.ToPixel<Rgba32>());
 
-        using var image2 = new Image<Rgba32>(image.Width, image.Height, Color.Yellow.ToRgba32());
+        using var image2 = new Image<Rgba32>(image.Width, image.Height, Color.Yellow.ToPixel<Rgba32>());
 
         image.Frames.AddFrame(image1.Frames.RootFrame);
         image.Frames.AddFrame(image2.Frames.RootFrame);
@@ -97,8 +97,8 @@ public class TiffEncoderMultiframeTests : TiffEncoderBaseTester
             ImageFrame<Rgba32> frame1 = output.Frames[1];
             ImageFrame<Rgba32> frame2 = output.Frames[2];
 
-            Assert.Equal(Color.Green.ToRgba32(), frame1[10, 10]);
-            Assert.Equal(Color.Yellow.ToRgba32(), frame2[10, 10]);
+            Assert.Equal(Color.Green.ToPixel<Rgba32>(), frame1[10, 10]);
+            Assert.Equal(Color.Yellow.ToPixel<Rgba32>(), frame2[10, 10]);
 
             Assert.Equal(TiffCompression.Deflate, frame1.Metadata.GetTiffMetadata().Compression);
             Assert.Equal(TiffCompression.Deflate, frame1.Metadata.GetTiffMetadata().Compression);
@@ -122,11 +122,11 @@ public class TiffEncoderMultiframeTests : TiffEncoderBaseTester
     {
         using Image<TPixel> image = provider.GetImage();
 
-        using var image0 = new Image<Rgba32>(image.Width, image.Height, Color.Red.ToRgba32());
+        using var image0 = new Image<Rgba32>(image.Width, image.Height, Color.Red.ToPixel<Rgba32>());
 
-        using var image1 = new Image<Rgba32>(image.Width, image.Height, Color.Green.ToRgba32());
+        using var image1 = new Image<Rgba32>(image.Width, image.Height, Color.Green.ToPixel<Rgba32>());
 
-        using var image2 = new Image<Rgba32>(image.Width, image.Height, Color.Yellow.ToRgba32());
+        using var image2 = new Image<Rgba32>(image.Width, image.Height, Color.Yellow.ToPixel<Rgba32>());
 
         image.Frames.AddFrame(image0.Frames.RootFrame);
         image.Frames.AddFrame(image1.Frames.RootFrame);
@@ -154,9 +154,9 @@ public class TiffEncoderMultiframeTests : TiffEncoderBaseTester
             ImageFrame<Rgba32> frame1 = output.Frames[1];
             ImageFrame<Rgba32> frame2 = output.Frames[2];
 
-            Assert.Equal(Color.Red.ToRgba32(), frame0[10, 10]);
-            Assert.Equal(Color.Green.ToRgba32(), frame1[10, 10]);
-            Assert.Equal(Color.Yellow.ToRgba32(), frame2[10, 10]);
+            Assert.Equal(Color.Red.ToPixel<Rgba32>(), frame0[10, 10]);
+            Assert.Equal(Color.Green.ToPixel<Rgba32>(), frame1[10, 10]);
+            Assert.Equal(Color.Yellow.ToPixel<Rgba32>(), frame2[10, 10]);
 
             Assert.Equal(TiffCompression.Lzw, frame0.Metadata.GetTiffMetadata().Compression);
             Assert.Equal(TiffCompression.Lzw, frame1.Metadata.GetTiffMetadata().Compression);
diff --git a/tests/ImageSharp.Tests/Formats/WebP/PredictorEncoderTests.cs b/tests/ImageSharp.Tests/Formats/WebP/PredictorEncoderTests.cs
index f0961de6b..b4279b045 100644
--- a/tests/ImageSharp.Tests/Formats/WebP/PredictorEncoderTests.cs
+++ b/tests/ImageSharp.Tests/Formats/WebP/PredictorEncoderTests.cs
@@ -80,7 +80,7 @@ public class PredictorEncoderTests
 
         // Convert image pixels to bgra array.
         byte[] imgBytes = File.ReadAllBytes(TestImageFullPath(TestImages.Webp.Peak));
-        using var image = Image.Load<Rgba32>(imgBytes);
+        using Image<Rgba32> image = Image.Load<Rgba32>(imgBytes);
         uint[] bgra = ToBgra(image);
 
         const int colorTransformBits = 3;
@@ -110,7 +110,7 @@ public class PredictorEncoderTests
 
         // Convert image pixels to bgra array.
         byte[] imgBytes = File.ReadAllBytes(TestImageFullPath(TestImages.Webp.Lossy.BikeSmall));
-        using var image = Image.Load<Rgba32>(imgBytes);
+        using Image<Rgba32> image = Image.Load<Rgba32>(imgBytes);
         uint[] bgra = ToBgra(image);
 
         const int colorTransformBits = 4;
@@ -149,10 +149,8 @@ public class PredictorEncoderTests
     private static Bgra32 ToBgra32<TPixel>(TPixel color)
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        Rgba32 rgba = default;
-        color.ToRgba32(ref rgba);
-        var bgra = new Bgra32(rgba.R, rgba.G, rgba.B, rgba.A);
-        return bgra;
+        Rgba32 rgba = color.ToRgba32();
+        return new Bgra32(rgba.R, rgba.G, rgba.B, rgba.A);
     }
 
     private static string TestImageFullPath(string path)
diff --git a/tests/ImageSharp.Tests/Image/ImageFrameCollectionTests.Generic.cs b/tests/ImageSharp.Tests/Image/ImageFrameCollectionTests.Generic.cs
index 62d1ef4db..71c9e07fc 100644
--- a/tests/ImageSharp.Tests/Image/ImageFrameCollectionTests.Generic.cs
+++ b/tests/ImageSharp.Tests/Image/ImageFrameCollectionTests.Generic.cs
@@ -237,7 +237,7 @@ public abstract partial class ImageFrameCollectionTests
             using (this.Image.Frames.CreateFrame(Color.HotPink))
             {
                 Assert.Equal(2, this.Image.Frames.Count);
-                this.Image.Frames[1].ComparePixelBufferTo(Color.HotPink);
+                this.Image.Frames[1].ComparePixelBufferTo(Color.HotPink.ToPixel<Rgba32>());
             }
         }
 
diff --git a/tests/ImageSharp.Tests/Image/ImageFrameCollectionTests.NonGeneric.cs b/tests/ImageSharp.Tests/Image/ImageFrameCollectionTests.NonGeneric.cs
index f9ff6ba69..a42dcc481 100644
--- a/tests/ImageSharp.Tests/Image/ImageFrameCollectionTests.NonGeneric.cs
+++ b/tests/ImageSharp.Tests/Image/ImageFrameCollectionTests.NonGeneric.cs
@@ -1,7 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using SixLabors.ImageSharp.Advanced;
 using SixLabors.ImageSharp.Formats.Gif;
 using SixLabors.ImageSharp.PixelFormats;
 
@@ -23,13 +22,13 @@ public abstract partial class ImageFrameCollectionTests
                 this.Image.Configuration,
                 this.Image.Width,
                 this.Image.Height,
-                Color.Blue))
+                Color.Blue.ToPixel<Bgra32>()))
             {
                 this.Collection.AddFrame(sourceImage.Frames.RootFrame);
             }
 
             Rgba32[] expectedAllBlue =
-                Enumerable.Repeat((Rgba32)Color.Blue, this.Image.Width * this.Image.Height).ToArray();
+                Enumerable.Repeat(Color.Blue.ToPixel<Rgba32>(), this.Image.Width * this.Image.Height).ToArray();
 
             Assert.Equal(2, this.Collection.Count);
             ImageFrame<Rgba32> actualFrame = (ImageFrame<Rgba32>)this.Collection[1];
@@ -44,13 +43,13 @@ public abstract partial class ImageFrameCollectionTests
                 this.Image.Configuration,
                 this.Image.Width,
                 this.Image.Height,
-                Color.Blue))
+                Color.Blue.ToPixel<Bgra32>()))
             {
                 this.Collection.InsertFrame(0, sourceImage.Frames.RootFrame);
             }
 
             Rgba32[] expectedAllBlue =
-                Enumerable.Repeat((Rgba32)Color.Blue, this.Image.Width * this.Image.Height).ToArray();
+                Enumerable.Repeat(Color.Blue.ToPixel<Rgba32>(), this.Image.Width * this.Image.Height).ToArray();
 
             Assert.Equal(2, this.Collection.Count);
             ImageFrame<Rgba32> actualFrame = (ImageFrame<Rgba32>)this.Collection[0];
@@ -177,7 +176,7 @@ public abstract partial class ImageFrameCollectionTests
 
             ImageFrame<Rgba32> frame = (ImageFrame<Rgba32>)this.Image.Frames[1];
 
-            frame.ComparePixelBufferTo(Color.HotPink);
+            frame.ComparePixelBufferTo(Color.HotPink.ToPixel<Rgba32>());
         }
 
         [Fact]
@@ -279,7 +278,7 @@ public abstract partial class ImageFrameCollectionTests
         {
             using Image source = provider.GetImage();
             using Image<TPixel> dest = new(source.Configuration, source.Width, source.Height);
-            
+
             // Giphy.gif has 5 frames
             ImportFrameAs<Bgra32>(source.Frames, dest.Frames, 0);
             ImportFrameAs<Argb32>(source.Frames, dest.Frames, 1);
diff --git a/tests/ImageSharp.Tests/Image/ImageFrameTests.cs b/tests/ImageSharp.Tests/Image/ImageFrameTests.cs
index 3b9779ea4..e09ef487a 100644
--- a/tests/ImageSharp.Tests/Image/ImageFrameTests.cs
+++ b/tests/ImageSharp.Tests/Image/ImageFrameTests.cs
@@ -35,9 +35,9 @@ public class ImageFrameTests
             ImageFrame<Rgba32> frame = image.Frames.RootFrame;
             Rgba32 val = frame[3, 4];
             Assert.Equal(default(Rgba32), val);
-            frame[3, 4] = Color.Red;
+            frame[3, 4] = Color.Red.ToPixel<Rgba32>();
             val = frame[3, 4];
-            Assert.Equal(Color.Red.ToRgba32(), val);
+            Assert.Equal(Color.Red.ToPixel<Rgba32>(), val);
         }
 
         public static TheoryData<bool, int> OutOfRangeData = new TheoryData<bool, int>()
diff --git a/tests/ImageSharp.Tests/Image/ImageTests.LoadPixelData.cs b/tests/ImageSharp.Tests/Image/ImageTests.LoadPixelData.cs
index 238096be4..5762264d2 100644
--- a/tests/ImageSharp.Tests/Image/ImageTests.LoadPixelData.cs
+++ b/tests/ImageSharp.Tests/Image/ImageTests.LoadPixelData.cs
@@ -15,19 +15,17 @@ public partial class ImageTests
         [ValidateDisposedMemoryAllocations]
         public void FromPixels(bool useSpan)
         {
-            Rgba32[] data = { Color.Black, Color.White, Color.White, Color.Black, };
+            Rgba32[] data = { Color.Black.ToPixel<Rgba32>(), Color.White.ToPixel<Rgba32>(), Color.White.ToPixel<Rgba32>(), Color.Black.ToPixel<Rgba32>(), };
 
-            using (Image<Rgba32> img = useSpan
-                                           ? Image.LoadPixelData<Rgba32>(data.AsSpan(), 2, 2)
-                                           : Image.LoadPixelData<Rgba32>(data, 2, 2))
-            {
-                Assert.NotNull(img);
-                Assert.Equal(Color.Black, (Color)img[0, 0]);
-                Assert.Equal(Color.White, (Color)img[0, 1]);
+            using Image<Rgba32> img = useSpan
+                ? Image.LoadPixelData<Rgba32>(data.AsSpan(), 2, 2)
+                : Image.LoadPixelData<Rgba32>(data, 2, 2);
+            Assert.NotNull(img);
+            Assert.Equal(Color.Black, Color.FromPixel(img[0, 0]));
+            Assert.Equal(Color.White, Color.FromPixel(img[0, 1]));
 
-                Assert.Equal(Color.White, (Color)img[1, 0]);
-                Assert.Equal(Color.Black, (Color)img[1, 1]);
-            }
+            Assert.Equal(Color.White, Color.FromPixel(img[1, 0]));
+            Assert.Equal(Color.Black, Color.FromPixel(img[1, 1]));
         }
 
         [Theory]
@@ -36,23 +34,22 @@ public partial class ImageTests
         public void FromBytes(bool useSpan)
         {
             byte[] data =
-                {
-                    0, 0, 0, 255, // 0,0
-                    255, 255, 255, 255, // 0,1
-                    255, 255, 255, 255, // 1,0
-                    0, 0, 0, 255, // 1,1
-                };
-            using (Image<Rgba32> img = useSpan
-                                           ? Image.LoadPixelData<Rgba32>(data.AsSpan(), 2, 2)
-                                           : Image.LoadPixelData<Rgba32>(data, 2, 2))
             {
-                Assert.NotNull(img);
-                Assert.Equal(Color.Black, (Color)img[0, 0]);
-                Assert.Equal(Color.White, (Color)img[0, 1]);
+                0, 0, 0, 255, // 0,0
+                255, 255, 255, 255, // 0,1
+                255, 255, 255, 255, // 1,0
+                0, 0, 0, 255, // 1,1
+            };
+
+            using Image<Rgba32> img = useSpan
+                ? Image.LoadPixelData<Rgba32>(data.AsSpan(), 2, 2)
+                : Image.LoadPixelData<Rgba32>(data, 2, 2);
+            Assert.NotNull(img);
+            Assert.Equal(Color.Black, Color.FromPixel(img[0, 0]));
+            Assert.Equal(Color.White, Color.FromPixel(img[0, 1]));
 
-                Assert.Equal(Color.White, (Color)img[1, 0]);
-                Assert.Equal(Color.Black, (Color)img[1, 1]);
-            }
+            Assert.Equal(Color.White, Color.FromPixel(img[1, 0]));
+            Assert.Equal(Color.Black, Color.FromPixel(img[1, 1]));
         }
     }
 }
diff --git a/tests/ImageSharp.Tests/Image/ImageTests.WrapMemory.cs b/tests/ImageSharp.Tests/Image/ImageTests.WrapMemory.cs
index 9aaefa41e..f22a55aae 100644
--- a/tests/ImageSharp.Tests/Image/ImageTests.WrapMemory.cs
+++ b/tests/ImageSharp.Tests/Image/ImageTests.WrapMemory.cs
@@ -154,8 +154,8 @@ public partial class ImageTests
                 using (var memoryManager = new BitmapMemoryManager(bmp))
                 {
                     Memory<Bgra32> memory = memoryManager.Memory;
-                    Bgra32 bg = Color.Red;
-                    Bgra32 fg = Color.Green;
+                    Bgra32 bg = Color.Red.ToPixel<Bgra32>();
+                    Bgra32 fg = Color.Green.ToPixel<Bgra32>();
 
                     using (var image = Image.WrapMemory(memory, bmp.Width, bmp.Height))
                     {
@@ -198,8 +198,8 @@ public partial class ImageTests
             using (var bmp = new Bitmap(51, 23))
             {
                 var memoryManager = new BitmapMemoryManager(bmp);
-                Bgra32 bg = Color.Red;
-                Bgra32 fg = Color.Green;
+                Bgra32 bg = Color.Red.ToPixel<Bgra32>();
+                Bgra32 fg = Color.Green.ToPixel<Bgra32>();
 
                 using (var image = Image.WrapMemory(memoryManager, bmp.Width, bmp.Height))
                 {
@@ -258,8 +258,8 @@ public partial class ImageTests
                 {
                     Memory<Bgra32> pixelMemory = memoryManager.Memory;
                     Memory<byte> byteMemory = new CastMemoryManager<Bgra32, byte>(pixelMemory).Memory;
-                    Bgra32 bg = Color.Red;
-                    Bgra32 fg = Color.Green;
+                    Bgra32 bg = Color.Red.ToPixel<Bgra32>();
+                    Bgra32 fg = Color.Green.ToPixel<Bgra32>();
 
                     using (var image = Image.WrapMemory<Bgra32>(byteMemory, bmp.Width, bmp.Height))
                     {
@@ -355,8 +355,8 @@ public partial class ImageTests
                 using (var memoryManager = new BitmapMemoryManager(bmp))
                 {
                     Memory<Bgra32> pixelMemory = memoryManager.Memory;
-                    Bgra32 bg = Color.Red;
-                    Bgra32 fg = Color.Green;
+                    Bgra32 bg = Color.Red.ToPixel<Bgra32>();
+                    Bgra32 fg = Color.Green.ToPixel<Bgra32>();
 
                     fixed (void* p = pixelMemory.Span)
                     {
diff --git a/tests/ImageSharp.Tests/Image/ImageTests.cs b/tests/ImageSharp.Tests/Image/ImageTests.cs
index ca51f7f5c..ac91ea948 100644
--- a/tests/ImageSharp.Tests/Image/ImageTests.cs
+++ b/tests/ImageSharp.Tests/Image/ImageTests.cs
@@ -61,7 +61,7 @@ public partial class ImageTests
         public void Configuration_Width_Height_BackgroundColor()
         {
             Configuration configuration = Configuration.Default.Clone();
-            Rgba32 color = Color.Aquamarine;
+            Rgba32 color = Color.Aquamarine.ToPixel<Rgba32>();
 
             using (Image<Rgba32> image = new(configuration, 11, 23, color))
             {
@@ -116,9 +116,9 @@ public partial class ImageTests
             using Image<Rgba32> image = new(this.configuration, 10, 10);
             Rgba32 val = image[3, 4];
             Assert.Equal(default(Rgba32), val);
-            image[3, 4] = Color.Red;
+            image[3, 4] = Color.Red.ToPixel<Rgba32>();
             val = image[3, 4];
-            Assert.Equal(Color.Red.ToRgba32(), val);
+            Assert.Equal(Color.Red.ToPixel<Rgba32>(), val);
         }
 
         public static TheoryData<bool, int> OutOfRangeData = new()
diff --git a/tests/ImageSharp.Tests/ImageInfoTests.cs b/tests/ImageSharp.Tests/ImageInfoTests.cs
index 73324eccd..576d14396 100644
--- a/tests/ImageSharp.Tests/ImageInfoTests.cs
+++ b/tests/ImageSharp.Tests/ImageInfoTests.cs
@@ -1,8 +1,8 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.Metadata;
+using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Tests;
 
diff --git a/tests/ImageSharp.Tests/ImageSharp.Tests.csproj b/tests/ImageSharp.Tests/ImageSharp.Tests.csproj
index e0c65475a..a389c8ab8 100644
--- a/tests/ImageSharp.Tests/ImageSharp.Tests.csproj
+++ b/tests/ImageSharp.Tests/ImageSharp.Tests.csproj
@@ -80,9 +80,5 @@
     <Service Include="{508349b6-6b84-4df5-91f0-309beebad82d}" />
   </ItemGroup>
 
-  <ItemGroup>
-    <Folder Include="Formats\Qoi\" />
-  </ItemGroup>
-
 </Project>
 
diff --git a/tests/ImageSharp.Tests/Issues/Issue594.cs b/tests/ImageSharp.Tests/Issues/Issue594.cs
index 51f1ef7c6..7f976a373 100644
--- a/tests/ImageSharp.Tests/Issues/Issue594.cs
+++ b/tests/ImageSharp.Tests/Issues/Issue594.cs
@@ -8,10 +8,8 @@ namespace SixLabors.ImageSharp.Tests.Issues;
 
 public class Issue594
 {
-    // This test fails for unknown reason in Release mode on linux and is meant to help reproducing the issue
-    // see https://github.com/SixLabors/ImageSharp/issues/594
-    [Fact(Skip = "Skipped because of issue #594")]
-    public void NormalizedByte4()
+    [Fact]
+    public void NormalizedByte4Test()
     {
         // Test PackedValue
         Assert.Equal(0x0U, new NormalizedByte4(Vector4.Zero).PackedValue);
@@ -33,68 +31,25 @@ public class Issue594
         Assert.Equal(0, scaled.W);
 
         // Test FromScaledVector4.
-        var pixel = default(NormalizedByte4);
-        pixel.FromScaledVector4(scaled);
+        NormalizedByte4 pixel = NormalizedByte4.FromScaledVector4(scaled);
         Assert.Equal(0x81818181, pixel.PackedValue);
 
         // Test Ordering
-        float x = 0.1f;
-        float y = -0.3f;
-        float z = 0.5f;
-        float w = -0.7f;
-        Assert.Equal(0xA740DA0D, new NormalizedByte4(x, y, z, w).PackedValue);
-        var n = default(NormalizedByte4);
-        n.FromRgba32(new Rgba32(141, 90, 192, 39));
+        const float x = 0.1f;
+        const float y = -0.3f;
+        const float z = 0.5f;
+        const float w = -0.7f;
+
+        pixel = new(x, y, z, w);
+        Assert.Equal(0xA740DA0D, pixel.PackedValue);
+        NormalizedByte4 n = NormalizedByte4.FromRgba32(pixel.ToRgba32());
         Assert.Equal(0xA740DA0D, n.PackedValue);
 
         Assert.Equal(958796544U, new NormalizedByte4(0.0008f, 0.15f, 0.30f, 0.45f).PackedValue);
-
-        // var rgb = default(Rgb24);
-        // var rgba = default(Rgba32);
-        // var bgr = default(Bgr24);
-        // var bgra = default(Bgra32);
-        // var argb = default(Argb32);
-
-        // new NormalizedByte4(x, y, z, w).ToRgb24(ref rgb);
-        // Assert.Equal(rgb, new Rgb24(141, 90, 192));
-
-        // new NormalizedByte4(x, y, z, w).ToRgba32(ref rgba);
-        // Assert.Equal(rgba, new Rgba32(141, 90, 192, 39));
-
-        // new NormalizedByte4(x, y, z, w).ToBgr24(ref bgr);
-        // Assert.Equal(bgr, new Bgr24(141, 90, 192));
-
-        // new NormalizedByte4(x, y, z, w).ToBgra32(ref bgra);
-        // Assert.Equal(bgra, new Bgra32(141, 90, 192, 39));  // this assert fails in Release build on linux (#594)
-
-        // new NormalizedByte4(x, y, z, w).ToArgb32(ref argb);
-        // Assert.Equal(argb, new Argb32(141, 90, 192, 39));
-
-        // http://community.monogame.net/t/normalizedbyte4-texture2d-gives-different-results-from-xna/8012/8
-        // var r = default(NormalizedByte4);
-        // r.FromRgba32(new Rgba32(9, 115, 202, 127));
-        // r.ToRgba32(ref rgba);
-        // Assert.Equal(rgba, new Rgba32(9, 115, 202, 127));
-
-        // r.PackedValue = 0xff4af389;
-        // r.ToRgba32(ref rgba);
-        // Assert.Equal(rgba, new Rgba32(9, 115, 202, 127));
-
-        // r = default(NormalizedByte4);
-        // r.FromArgb32(new Argb32(9, 115, 202, 127));
-        // r.ToArgb32(ref argb);
-        // Assert.Equal(argb, new Argb32(9, 115, 202, 127));
-
-        // r = default(NormalizedByte4);
-        // r.FromBgra32(new Bgra32(9, 115, 202, 127));
-        // r.ToBgra32(ref bgra);
-        // Assert.Equal(bgra, new Bgra32(9, 115, 202, 127));
     }
 
-    // This test fails for unknown reason in Release mode on linux and is meant to help reproducing the issue
-    // see https://github.com/SixLabors/ImageSharp/issues/594
-    [Fact(Skip = "Skipped because of issue #594")]
-    public void NormalizedShort4()
+    [Fact]
+    public void NormalizedShort4Test()
     {
         // Test PackedValue
         Assert.Equal(0x0UL, new NormalizedShort4(Vector4.Zero).PackedValue);
@@ -116,59 +71,20 @@ public class Issue594
         Assert.Equal(1, scaled.W);
 
         // Test FromScaledVector4.
-        var pixel = default(NormalizedShort4);
-        pixel.FromScaledVector4(scaled);
+        NormalizedShort4 pixel = NormalizedShort4.FromScaledVector4(scaled);
         Assert.Equal(0x7FFF7FFF7FFF7FFFUL, pixel.PackedValue);
 
         // Test Ordering
-        float x = 0.1f;
-        float y = -0.3f;
-        float z = 0.5f;
-        float w = -0.7f;
+        const float x = 0.1f;
+        const float y = -0.3f;
+        const float z = 0.5f;
+        const float w = -0.7f;
         Assert.Equal(0xa6674000d99a0ccd, new NormalizedShort4(x, y, z, w).PackedValue);
         Assert.Equal(4150390751449251866UL, new NormalizedShort4(0.0008f, 0.15f, 0.30f, 0.45f).PackedValue);
-
-        // var rgb = default(Rgb24);
-        // var rgba = default(Rgba32);
-        // var bgr = default(Bgr24);
-        // var bgra = default(Bgra32);
-        // var argb = default(Argb32);
-
-        // new NormalizedShort4(x, y, z, w).ToRgb24(ref rgb);
-        // Assert.Equal(rgb, new Rgb24(141, 90, 192));
-
-        // new NormalizedShort4(x, y, z, w).ToRgba32(ref rgba);
-        // Assert.Equal(rgba, new Rgba32(141, 90, 192, 39)); // this assert fails in Release build on linux (#594)
-
-        // new NormalizedShort4(x, y, z, w).ToBgr24(ref bgr);
-        // Assert.Equal(bgr, new Bgr24(141, 90, 192));
-
-        // new NormalizedShort4(x, y, z, w).ToBgra32(ref bgra);
-        // Assert.Equal(bgra, new Bgra32(141, 90, 192, 39));
-
-        // new NormalizedShort4(x, y, z, w).ToArgb32(ref argb);
-        // Assert.Equal(argb, new Argb32(141, 90, 192, 39));
-
-        // var r = default(NormalizedShort4);
-        // r.FromRgba32(new Rgba32(9, 115, 202, 127));
-        // r.ToRgba32(ref rgba);
-        // Assert.Equal(rgba, new Rgba32(9, 115, 202, 127));
-
-        // r = default(NormalizedShort4);
-        // r.FromBgra32(new Bgra32(9, 115, 202, 127));
-        // r.ToBgra32(ref bgra);
-        // Assert.Equal(bgra, new Bgra32(9, 115, 202, 127));
-
-        // r = default(NormalizedShort4);
-        // r.FromArgb32(new Argb32(9, 115, 202, 127));
-        // r.ToArgb32(ref argb);
-        // Assert.Equal(argb, new Argb32(9, 115, 202, 127));
     }
 
-    // This test fails for unknown reason in Release mode on linux and is meant to help reproducing the issue
-    // see https://github.com/SixLabors/ImageSharp/issues/594
-    [Fact(Skip = "Skipped because of issue #594")]
-    public void Short4()
+    [Fact]
+    public void Short4Test()
     {
         // Test the limits.
         Assert.Equal(0x0UL, new Short4(Vector4.Zero).PackedValue);
@@ -192,8 +108,7 @@ public class Issue594
         Assert.Equal(1, scaled.W);
 
         // Test FromScaledVector4.
-        var pixel = default(Short4);
-        pixel.FromScaledVector4(scaled);
+        Short4 pixel = Short4.FromScaledVector4(scaled);
         Assert.Equal(0x7FFF7FFF7FFF7FFFUL, pixel.PackedValue);
 
         // Test clamping.
@@ -212,52 +127,11 @@ public class Issue594
         z = 29623;
         w = 193;
         Assert.Equal(0x00c173b7316d2d1bUL, new Short4(x, y, z, w).PackedValue);
-
-        // var rgb = default(Rgb24);
-        // var rgba = default(Rgba32);
-        // var bgr = default(Bgr24);
-        // var bgra = default(Bgra32);
-        // var argb = default(Argb32);
-
-        // new Short4(x, y, z, w).ToRgb24(ref rgb);
-        // Assert.Equal(rgb, new Rgb24(172, 177, 243)); // this assert fails in Release build on linux (#594)
-
-        // new Short4(x, y, z, w).ToRgba32(ref rgba);
-        // Assert.Equal(rgba, new Rgba32(172, 177, 243, 128));
-
-        // new Short4(x, y, z, w).ToBgr24(ref bgr);
-        // Assert.Equal(bgr, new Bgr24(172, 177, 243));
-
-        // new Short4(x, y, z, w).ToBgra32(ref bgra);
-        // Assert.Equal(bgra, new Bgra32(172, 177, 243, 128));
-
-        // new Short4(x, y, z, w).ToArgb32(ref argb);
-        // Assert.Equal(argb, new Argb32(172, 177, 243, 128));
-
-        // var r = default(Short4);
-        // r.FromRgba32(new Rgba32(20, 38, 0, 255));
-        // r.ToRgba32(ref rgba);
-        // Assert.Equal(rgba, new Rgba32(20, 38, 0, 255));
-
-        // r = default(Short4);
-        // r.FromBgra32(new Bgra32(20, 38, 0, 255));
-        // r.ToBgra32(ref bgra);
-        // Assert.Equal(bgra, new Bgra32(20, 38, 0, 255));
-
-        // r = default(Short4);
-        // r.FromArgb32(new Argb32(20, 38, 0, 255));
-        // r.ToArgb32(ref argb);
-        // Assert.Equal(argb, new Argb32(20, 38, 0, 255));
     }
 
+    // TODO: Use tolerant comparer.
     // Comparison helpers with small tolerance to allow for floating point rounding during computations.
-    public static bool Equal(float a, float b)
-    {
-        return Math.Abs(a - b) < 1e-5;
-    }
+    public static bool Equal(float a, float b) => Math.Abs(a - b) < 1e-5;
 
-    public static bool Equal(Vector4 a, Vector4 b)
-    {
-        return Equal(a.X, b.X) && Equal(a.Y, b.Y) && Equal(a.Z, b.Z) && Equal(a.W, b.W);
-    }
+    public static bool Equal(Vector4 a, Vector4 b) => Equal(a.X, b.X) && Equal(a.Y, b.Y) && Equal(a.Z, b.Z) && Equal(a.W, b.W);
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/A8Tests.cs b/tests/ImageSharp.Tests/PixelFormats/A8Tests.cs
index 95574a4d6..4b4e84b4b 100644
--- a/tests/ImageSharp.Tests/PixelFormats/A8Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/A8Tests.cs
@@ -2,6 +2,7 @@
 // Licensed under the Six Labors Split License.
 
 using System.Numerics;
+using System.Runtime.CompilerServices;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Tests.PixelFormats;
@@ -28,8 +29,8 @@ public class A8Tests
     [Fact]
     public void A8_Equality()
     {
-        var left = new A8(16);
-        var right = new A8(32);
+        A8 left = new(16);
+        A8 right = new(32);
 
         Assert.True(left == new A8(16));
         Assert.True(left != right);
@@ -40,12 +41,11 @@ public class A8Tests
     public void A8_FromScaledVector4()
     {
         // Arrange
-        A8 alpha = default;
-        int expected = 128;
+        const int expected = 128;
         Vector4 scaled = new A8(.5F).ToScaledVector4();
 
         // Act
-        alpha.FromScaledVector4(scaled);
+        A8 alpha = A8.FromScaledVector4(scaled);
         byte actual = alpha.PackedValue;
 
         // Assert
@@ -56,7 +56,7 @@ public class A8Tests
     public void A8_ToScaledVector4()
     {
         // Arrange
-        var alpha = new A8(.5F);
+        A8 alpha = new(.5F);
 
         // Act
         Vector4 actual = alpha.ToScaledVector4();
@@ -72,10 +72,10 @@ public class A8Tests
     public void A8_ToVector4()
     {
         // Arrange
-        var alpha = new A8(.5F);
+        A8 alpha = new(.5F);
 
         // Act
-        var actual = alpha.ToVector4();
+        Vector4 actual = alpha.ToVector4();
 
         // Assert
         Assert.Equal(0, actual.X);
@@ -87,11 +87,10 @@ public class A8Tests
     [Fact]
     public void A8_ToRgba32()
     {
-        var input = new A8(128);
-        var expected = new Rgba32(0, 0, 0, 128);
+        A8 input = new(128);
+        Rgba32 expected = new(0, 0, 0, 128);
 
-        Rgba32 actual = default;
-        input.ToRgba32(ref actual);
+        Rgba32 actual = input.ToRgba32();
         Assert.Equal(expected, actual);
     }
 
@@ -99,13 +98,27 @@ public class A8Tests
     public void A8_FromBgra5551()
     {
         // arrange
-        var alpha = default(A8);
-        byte expected = byte.MaxValue;
+        const byte expected = byte.MaxValue;
 
         // act
-        alpha.FromBgra5551(new Bgra5551(0.0f, 0.0f, 0.0f, 1.0f));
+        A8 alpha = A8.FromBgra5551(new Bgra5551(0.0f, 0.0f, 0.0f, 1.0f));
 
         // assert
         Assert.Equal(expected, alpha.PackedValue);
     }
+
+    [Fact]
+    public void A8_PixelInformation()
+    {
+        PixelTypeInfo info = A8.GetPixelTypeInfo();
+        Assert.Equal(Unsafe.SizeOf<A8>() * 8, info.BitsPerPixel);
+        Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
+        Assert.Equal(PixelColorType.Alpha, info.ColorType);
+
+        PixelComponentInfo componentInfo = info.ComponentInfo.Value;
+        Assert.Equal(1, componentInfo.ComponentCount);
+        Assert.Equal(0, componentInfo.Padding);
+        Assert.Equal(8, componentInfo.GetComponentPrecision(0));
+        Assert.Equal(8, componentInfo.GetMaximumComponentPrecision());
+    }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/Abgr32Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Abgr32Tests.cs
index 13c84784c..98fdce5db 100644
--- a/tests/ImageSharp.Tests/PixelFormats/Abgr32Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/Abgr32Tests.cs
@@ -2,6 +2,7 @@
 // Licensed under the Six Labors Split License.
 
 using System.Numerics;
+using System.Runtime.CompilerServices;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Tests.PixelFormats;
@@ -15,8 +16,8 @@ public class Abgr32Tests
     [Fact]
     public void AreEqual()
     {
-        var color1 = new Abgr32(byte.MaxValue, byte.MaxValue, byte.MaxValue, byte.MaxValue);
-        var color2 = new Abgr32(byte.MaxValue, byte.MaxValue, byte.MaxValue);
+        Abgr32 color1 = new(byte.MaxValue, byte.MaxValue, byte.MaxValue, byte.MaxValue);
+        Abgr32 color2 = new(byte.MaxValue, byte.MaxValue, byte.MaxValue);
 
         Assert.Equal(color1, color2);
     }
@@ -27,8 +28,8 @@ public class Abgr32Tests
     [Fact]
     public void AreNotEqual()
     {
-        var color1 = new Abgr32(0, 0, byte.MaxValue, byte.MaxValue);
-        var color2 = new Abgr32(byte.MaxValue, byte.MaxValue, byte.MaxValue);
+        Abgr32 color1 = new(0, 0, byte.MaxValue, byte.MaxValue);
+        Abgr32 color2 = new(byte.MaxValue, byte.MaxValue, byte.MaxValue);
 
         Assert.NotEqual(color1, color2);
     }
@@ -46,7 +47,7 @@ public class Abgr32Tests
     [MemberData(nameof(ColorData))]
     public void Constructor(byte b, byte g, byte r, byte a)
     {
-        var p = new Abgr32(r, g, b, a);
+        Abgr32 p = new(r, g, b, a);
 
         Assert.Equal(r, p.R);
         Assert.Equal(g, p.G);
@@ -57,7 +58,7 @@ public class Abgr32Tests
     [Fact]
     public unsafe void ByteLayoutIsSequentialBgra()
     {
-        var color = new Abgr32(1, 2, 3, 4);
+        Abgr32 color = new(1, 2, 3, 4);
         byte* ptr = (byte*)&color;
 
         Assert.Equal(4, ptr[0]);
@@ -70,8 +71,8 @@ public class Abgr32Tests
     [MemberData(nameof(ColorData))]
     public void Equality_WhenTrue(byte r, byte g, byte b, byte a)
     {
-        var x = new Abgr32(r, g, b, a);
-        var y = new Abgr32(r, g, b, a);
+        Abgr32 x = new(r, g, b, a);
+        Abgr32 y = new(r, g, b, a);
 
         Assert.True(x.Equals(y));
         Assert.True(x.Equals((object)y));
@@ -85,8 +86,8 @@ public class Abgr32Tests
     [InlineData(1, 255, 0, 0, 0, 255, 0, 0)]
     public void Equality_WhenFalse(byte b1, byte g1, byte r1, byte a1, byte b2, byte g2, byte r2, byte a2)
     {
-        var x = new Abgr32(r1, g1, b1, a1);
-        var y = new Abgr32(r2, g2, b2, a2);
+        Abgr32 x = new(r1, g1, b1, a1);
+        Abgr32 y = new(r2, g2, b2, a2);
 
         Assert.False(x.Equals(y));
         Assert.False(x.Equals((object)y));
@@ -95,8 +96,7 @@ public class Abgr32Tests
     [Fact]
     public void FromRgba32()
     {
-        var abgr = default(Abgr32);
-        abgr.FromRgba32(new Rgba32(1, 2, 3, 4));
+        Abgr32 abgr = Abgr32.FromRgba32(new Rgba32(1, 2, 3, 4));
 
         Assert.Equal(1, abgr.R);
         Assert.Equal(2, abgr.G);
@@ -104,7 +104,7 @@ public class Abgr32Tests
         Assert.Equal(4, abgr.A);
     }
 
-    private static Vector4 Vec(byte r, byte g, byte b, byte a = 255) => new Vector4(
+    private static Vector4 Vec(byte r, byte g, byte b, byte a = 255) => new(
         r / 255f,
         g / 255f,
         b / 255f,
@@ -113,8 +113,7 @@ public class Abgr32Tests
     [Fact]
     public void FromVector4()
     {
-        var c = default(Abgr32);
-        c.FromVector4(Vec(1, 2, 3, 4));
+        Abgr32 c = Abgr32.FromVector4(Vec(1, 2, 3, 4));
 
         Assert.Equal(1, c.R);
         Assert.Equal(2, c.G);
@@ -125,7 +124,7 @@ public class Abgr32Tests
     [Fact]
     public void ToVector4()
     {
-        var abgr = new Abgr32(1, 2, 3, 4);
+        Abgr32 abgr = new(1, 2, 3, 4);
 
         Assert.Equal(Vec(1, 2, 3, 4), abgr.ToVector4());
     }
@@ -134,13 +133,30 @@ public class Abgr32Tests
     public void Abgr32_FromBgra5551()
     {
         // arrange
-        var abgr = default(Abgr32);
-        uint expected = uint.MaxValue;
+        const uint expected = uint.MaxValue;
 
         // act
-        abgr.FromBgra5551(new Bgra5551(1.0f, 1.0f, 1.0f, 1.0f));
+        Abgr32 abgr = Abgr32.FromBgra5551(new Bgra5551(1f, 1f, 1f, 1f));
 
         // assert
         Assert.Equal(expected, abgr.PackedValue);
     }
+
+    [Fact]
+    public void Abgr32_PixelInformation()
+    {
+        PixelTypeInfo info = Abgr32.GetPixelTypeInfo();
+        Assert.Equal(Unsafe.SizeOf<Abgr32>() * 8, info.BitsPerPixel);
+        Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
+        Assert.Equal(PixelColorType.Alpha | PixelColorType.BGR, info.ColorType);
+
+        PixelComponentInfo componentInfo = info.ComponentInfo.Value;
+        Assert.Equal(4, componentInfo.ComponentCount);
+        Assert.Equal(0, componentInfo.Padding);
+        Assert.Equal(8, componentInfo.GetComponentPrecision(0));
+        Assert.Equal(8, componentInfo.GetComponentPrecision(1));
+        Assert.Equal(8, componentInfo.GetComponentPrecision(2));
+        Assert.Equal(8, componentInfo.GetComponentPrecision(3));
+        Assert.Equal(8, componentInfo.GetMaximumComponentPrecision());
+    }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/Argb32Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Argb32Tests.cs
index 70012afb0..bcaf9265a 100644
--- a/tests/ImageSharp.Tests/PixelFormats/Argb32Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/Argb32Tests.cs
@@ -2,6 +2,7 @@
 // Licensed under the Six Labors Split License.
 
 using System.Numerics;
+using System.Runtime.CompilerServices;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Tests.PixelFormats;
@@ -15,10 +16,10 @@ public class Argb32Tests
     [Fact]
     public void AreEqual()
     {
-        var color1 = new Argb32(0.0f, 0.0f, 0.0f, 0.0f);
-        var color2 = new Argb32(new Vector4(0.0f));
-        var color3 = new Argb32(new Vector4(1.0f, 0.0f, 1.0f, 1.0f));
-        var color4 = new Argb32(1.0f, 0.0f, 1.0f, 1.0f);
+        Argb32 color1 = new(0.0f, 0.0f, 0.0f, 0.0f);
+        Argb32 color2 = new(new Vector4(0.0f));
+        Argb32 color3 = new(new Vector4(1f, 0.0f, 1f, 1f));
+        Argb32 color4 = new(1f, 0.0f, 1f, 1f);
 
         Assert.Equal(color1, color2);
         Assert.Equal(color3, color4);
@@ -30,10 +31,10 @@ public class Argb32Tests
     [Fact]
     public void AreNotEqual()
     {
-        var color1 = new Argb32(0.0f, 0.0f, 0.0f, 0.0f);
-        var color2 = new Argb32(new Vector4(1.0f));
-        var color3 = new Argb32(new Vector4(1.0f, 0.0f, 0.0f, 1.0f));
-        var color4 = new Argb32(1.0f, 1.0f, 0.0f, 1.0f);
+        Argb32 color1 = new(0.0f, 0.0f, 0.0f, 0.0f);
+        Argb32 color2 = new(new Vector4(1f));
+        Argb32 color3 = new(new Vector4(1f, 0.0f, 0.0f, 1f));
+        Argb32 color4 = new(1f, 1f, 0.0f, 1f);
 
         Assert.NotEqual(color1, color2);
         Assert.NotEqual(color3, color4);
@@ -45,25 +46,25 @@ public class Argb32Tests
     [Fact]
     public void ConstructorAssignsProperties()
     {
-        var color1 = new Argb32(1, .1f, .133f, .864f);
+        Argb32 color1 = new(1, .1f, .133f, .864f);
         Assert.Equal(255, color1.R);
         Assert.Equal((byte)Math.Round(.1f * 255), color1.G);
         Assert.Equal((byte)Math.Round(.133f * 255), color1.B);
         Assert.Equal((byte)Math.Round(.864f * 255), color1.A);
 
-        var color2 = new Argb32(1, .1f, .133f);
+        Argb32 color2 = new(1, .1f, .133f);
         Assert.Equal(255, color2.R);
         Assert.Equal(Math.Round(.1f * 255), color2.G);
         Assert.Equal(Math.Round(.133f * 255), color2.B);
         Assert.Equal(255, color2.A);
 
-        var color4 = new Argb32(new Vector3(1, .1f, .133f));
+        Argb32 color4 = new(new Vector3(1, .1f, .133f));
         Assert.Equal(255, color4.R);
         Assert.Equal(Math.Round(.1f * 255), color4.G);
         Assert.Equal(Math.Round(.133f * 255), color4.B);
         Assert.Equal(255, color4.A);
 
-        var color5 = new Argb32(new Vector4(1, .1f, .133f, .5f));
+        Argb32 color5 = new(new Vector4(1, .1f, .133f, .5f));
         Assert.Equal(255, color5.R);
         Assert.Equal(Math.Round(.1f * 255), color5.G);
         Assert.Equal(Math.Round(.133f * 255), color5.B);
@@ -93,7 +94,7 @@ public class Argb32Tests
     public void Argb32_ToScaledVector4()
     {
         // arrange
-        var argb = new Argb32(Vector4.One);
+        Argb32 argb = new(Vector4.One);
 
         // act
         Vector4 actual = argb.ToScaledVector4();
@@ -110,11 +111,10 @@ public class Argb32Tests
     {
         // arrange
         Vector4 scaled = new Argb32(Vector4.One).ToScaledVector4();
-        var pixel = default(Argb32);
-        uint expected = 0xFFFFFFFF;
+        const uint expected = 0xFFFFFFFF;
 
         // act
-        pixel.FromScaledVector4(scaled);
+        Argb32 pixel = Argb32.FromScaledVector4(scaled);
         uint actual = pixel.PackedValue;
 
         // assert
@@ -125,11 +125,10 @@ public class Argb32Tests
     public void Argb32_FromBgra5551()
     {
         // arrange
-        var argb = default(Argb32);
-        uint expected = uint.MaxValue;
+        const uint expected = uint.MaxValue;
 
         // act
-        argb.FromBgra5551(new Bgra5551(1.0f, 1.0f, 1.0f, 1.0f));
+        Argb32 argb = Argb32.FromBgra5551(new Bgra5551(1f, 1f, 1f, 1f));
 
         // assert
         Assert.Equal(expected, argb.PackedValue);
@@ -141,4 +140,22 @@ public class Argb32Tests
         Assert.Equal(Vector4.Zero, new Argb32(Vector4.One * -1234.0f).ToVector4());
         Assert.Equal(Vector4.One, new Argb32(Vector4.One * +1234.0f).ToVector4());
     }
+
+    [Fact]
+    public void Argb32_PixelInformation()
+    {
+        PixelTypeInfo info = Argb32.GetPixelTypeInfo();
+        Assert.Equal(Unsafe.SizeOf<Argb32>() * 8, info.BitsPerPixel);
+        Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
+        Assert.Equal(PixelColorType.Alpha | PixelColorType.RGB, info.ColorType);
+
+        PixelComponentInfo componentInfo = info.ComponentInfo.Value;
+        Assert.Equal(4, componentInfo.ComponentCount);
+        Assert.Equal(0, componentInfo.Padding);
+        Assert.Equal(8, componentInfo.GetComponentPrecision(0));
+        Assert.Equal(8, componentInfo.GetComponentPrecision(1));
+        Assert.Equal(8, componentInfo.GetComponentPrecision(2));
+        Assert.Equal(8, componentInfo.GetComponentPrecision(3));
+        Assert.Equal(8, componentInfo.GetMaximumComponentPrecision());
+    }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/Bgr24Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Bgr24Tests.cs
index 730e3996d..362e20bba 100644
--- a/tests/ImageSharp.Tests/PixelFormats/Bgr24Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/Bgr24Tests.cs
@@ -2,6 +2,7 @@
 // Licensed under the Six Labors Split License.
 
 using System.Numerics;
+using System.Runtime.CompilerServices;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Tests.PixelFormats;
@@ -12,8 +13,8 @@ public class Bgr24Tests
     [Fact]
     public void AreEqual()
     {
-        var color1 = new Bgr24(byte.MaxValue, 0, byte.MaxValue);
-        var color2 = new Bgr24(byte.MaxValue, 0, byte.MaxValue);
+        Bgr24 color1 = new(byte.MaxValue, 0, byte.MaxValue);
+        Bgr24 color2 = new(byte.MaxValue, 0, byte.MaxValue);
 
         Assert.Equal(color1, color2);
     }
@@ -21,8 +22,8 @@ public class Bgr24Tests
     [Fact]
     public void AreNotEqual()
     {
-        var color1 = new Bgr24(byte.MaxValue, 0, 0);
-        var color2 = new Bgr24(byte.MaxValue, 0, byte.MaxValue);
+        Bgr24 color1 = new(byte.MaxValue, 0, 0);
+        Bgr24 color2 = new(byte.MaxValue, 0, byte.MaxValue);
 
         Assert.NotEqual(color1, color2);
     }
@@ -33,7 +34,7 @@ public class Bgr24Tests
     [MemberData(nameof(ColorData))]
     public void Constructor(byte r, byte g, byte b)
     {
-        var p = new Rgb24(r, g, b);
+        Rgb24 p = new(r, g, b);
 
         Assert.Equal(r, p.R);
         Assert.Equal(g, p.G);
@@ -43,7 +44,7 @@ public class Bgr24Tests
     [Fact]
     public unsafe void ByteLayoutIsSequentialBgr()
     {
-        var color = new Bgr24(1, 2, 3);
+        Bgr24 color = new(1, 2, 3);
         byte* ptr = (byte*)&color;
 
         Assert.Equal(3, ptr[0]);
@@ -55,8 +56,8 @@ public class Bgr24Tests
     [MemberData(nameof(ColorData))]
     public void Equals_WhenTrue(byte r, byte g, byte b)
     {
-        var x = new Bgr24(r, g, b);
-        var y = new Bgr24(r, g, b);
+        Bgr24 x = new(r, g, b);
+        Bgr24 y = new(r, g, b);
 
         Assert.True(x.Equals(y));
         Assert.True(x.Equals((object)y));
@@ -69,8 +70,8 @@ public class Bgr24Tests
     [InlineData(1, 255, 0, 0, 255, 0)]
     public void Equals_WhenFalse(byte r1, byte g1, byte b1, byte r2, byte g2, byte b2)
     {
-        var a = new Bgr24(r1, g1, b1);
-        var b = new Bgr24(r2, g2, b2);
+        Bgr24 a = new(r1, g1, b1);
+        Bgr24 b = new(r2, g2, b2);
 
         Assert.False(a.Equals(b));
         Assert.False(a.Equals((object)b));
@@ -79,15 +80,14 @@ public class Bgr24Tests
     [Fact]
     public void FromRgba32()
     {
-        var rgb = default(Bgr24);
-        rgb.FromRgba32(new Rgba32(1, 2, 3, 4));
+        Bgr24 rgb = Bgr24.FromRgba32(new Rgba32(1, 2, 3, 4));
 
         Assert.Equal(1, rgb.R);
         Assert.Equal(2, rgb.G);
         Assert.Equal(3, rgb.B);
     }
 
-    private static Vector4 Vec(byte r, byte g, byte b, byte a = 255) => new Vector4(
+    private static Vector4 Vec(byte r, byte g, byte b, byte a = 255) => new(
         r / 255f,
         g / 255f,
         b / 255f,
@@ -96,8 +96,7 @@ public class Bgr24Tests
     [Fact]
     public void FromVector4()
     {
-        var rgb = default(Bgr24);
-        rgb.FromVector4(Vec(1, 2, 3, 4));
+        Bgr24 rgb = Bgr24.FromVector4(Vec(1, 2, 3, 4));
 
         Assert.Equal(1, rgb.R);
         Assert.Equal(2, rgb.G);
@@ -107,7 +106,7 @@ public class Bgr24Tests
     [Fact]
     public void ToVector4()
     {
-        var rgb = new Bgr24(1, 2, 3);
+        Bgr24 rgb = new(1, 2, 3);
 
         Assert.Equal(Vec(1, 2, 3), rgb.ToVector4());
     }
@@ -115,15 +114,29 @@ public class Bgr24Tests
     [Fact]
     public void Bgr24_FromBgra5551()
     {
-        // arrange
-        var bgr = default(Bgr24);
-
         // act
-        bgr.FromBgra5551(new Bgra5551(1.0f, 1.0f, 1.0f, 1.0f));
+        Bgr24 bgr = Bgr24.FromBgra5551(new Bgra5551(1f, 1f, 1f, 1f));
 
         // assert
         Assert.Equal(255, bgr.R);
         Assert.Equal(255, bgr.G);
         Assert.Equal(255, bgr.B);
     }
+
+    [Fact]
+    public void Bgr24_PixelInformation()
+    {
+        PixelTypeInfo info = Bgr24.GetPixelTypeInfo();
+        Assert.Equal(Unsafe.SizeOf<Bgr24>() * 8, info.BitsPerPixel);
+        Assert.Equal(PixelAlphaRepresentation.None, info.AlphaRepresentation);
+        Assert.Equal(PixelColorType.BGR, info.ColorType);
+
+        PixelComponentInfo componentInfo = info.ComponentInfo.Value;
+        Assert.Equal(3, componentInfo.ComponentCount);
+        Assert.Equal(0, componentInfo.Padding);
+        Assert.Equal(8, componentInfo.GetComponentPrecision(0));
+        Assert.Equal(8, componentInfo.GetComponentPrecision(1));
+        Assert.Equal(8, componentInfo.GetComponentPrecision(2));
+        Assert.Equal(8, componentInfo.GetMaximumComponentPrecision());
+    }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/Bgr565Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Bgr565Tests.cs
index 8245a578f..3c4a10423 100644
--- a/tests/ImageSharp.Tests/PixelFormats/Bgr565Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/Bgr565Tests.cs
@@ -2,6 +2,7 @@
 // Licensed under the Six Labors Split License.
 
 using System.Numerics;
+using System.Runtime.CompilerServices;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Tests.PixelFormats;
@@ -15,10 +16,10 @@ public class Bgr565Tests
     [Fact]
     public void AreEqual()
     {
-        var color1 = new Bgr565(0.0f, 0.0f, 0.0f);
-        var color2 = new Bgr565(new Vector3(0.0f));
-        var color3 = new Bgr565(new Vector3(1.0f, 0.0f, 1.0f));
-        var color4 = new Bgr565(1.0f, 0.0f, 1.0f);
+        Bgr565 color1 = new(0.0f, 0.0f, 0.0f);
+        Bgr565 color2 = new(new Vector3(0.0f));
+        Bgr565 color3 = new(new Vector3(1.0f, 0.0f, 1.0f));
+        Bgr565 color4 = new(1.0f, 0.0f, 1.0f);
 
         Assert.Equal(color1, color2);
         Assert.Equal(color3, color4);
@@ -30,10 +31,10 @@ public class Bgr565Tests
     [Fact]
     public void AreNotEqual()
     {
-        var color1 = new Bgr565(0.0f, 0.0f, 0.0f);
-        var color2 = new Bgr565(new Vector3(1.0f));
-        var color3 = new Bgr565(new Vector3(1.0f, 0.0f, 0.0f));
-        var color4 = new Bgr565(1.0f, 1.0f, 0.0f);
+        Bgr565 color1 = new(0.0f, 0.0f, 0.0f);
+        Bgr565 color2 = new(new Vector3(1.0f));
+        Bgr565 color3 = new(new Vector3(1.0f, 0.0f, 0.0f));
+        Bgr565 color4 = new(1.0f, 1.0f, 0.0f);
 
         Assert.NotEqual(color1, color2);
         Assert.NotEqual(color3, color4);
@@ -66,7 +67,7 @@ public class Bgr565Tests
     public void Bgr565_ToScaledVector4()
     {
         // arrange
-        var bgr = new Bgr565(Vector3.One);
+        Bgr565 bgr = new(Vector3.One);
 
         // act
         Vector4 actual = bgr.ToScaledVector4();
@@ -83,11 +84,10 @@ public class Bgr565Tests
     {
         // arrange
         Vector4 scaled = new Bgr565(Vector3.One).ToScaledVector4();
-        int expected = 0xFFFF;
-        var pixel = default(Bgr565);
+        const int expected = 0xFFFF;
 
         // act
-        pixel.FromScaledVector4(scaled);
+        Bgr565 pixel = Bgr565.FromScaledVector4(scaled);
         ushort actual = pixel.PackedValue;
 
         // assert
@@ -98,11 +98,10 @@ public class Bgr565Tests
     public void Bgr565_FromBgra5551()
     {
         // arrange
-        var bgr = default(Bgr565);
-        ushort expected = ushort.MaxValue;
+        const ushort expected = ushort.MaxValue;
 
         // act
-        bgr.FromBgra5551(new Bgra5551(1.0f, 1.0f, 1.0f, 1.0f));
+        Bgr565 bgr = Bgr565.FromBgra5551(new Bgra5551(1.0f, 1.0f, 1.0f, 1.0f));
 
         // assert
         Assert.Equal(expected, bgr.PackedValue);
@@ -112,14 +111,12 @@ public class Bgr565Tests
     public void Bgr565_FromArgb32()
     {
         // arrange
-        var bgr1 = default(Bgr565);
-        var bgr2 = default(Bgr565);
-        ushort expected1 = ushort.MaxValue;
-        ushort expected2 = ushort.MaxValue;
+        const ushort expected1 = ushort.MaxValue;
+        const ushort expected2 = ushort.MaxValue;
 
         // act
-        bgr1.FromArgb32(new Argb32(1.0f, 1.0f, 1.0f, 1.0f));
-        bgr2.FromArgb32(new Argb32(1.0f, 1.0f, 1.0f, 0.0f));
+        Bgr565 bgr1 = Bgr565.FromArgb32(new Argb32(1.0f, 1.0f, 1.0f, 1.0f));
+        Bgr565 bgr2 = Bgr565.FromArgb32(new Argb32(1.0f, 1.0f, 1.0f, 0.0f));
 
         // assert
         Assert.Equal(expected1, bgr1.PackedValue);
@@ -130,14 +127,12 @@ public class Bgr565Tests
     public void Bgr565_FromRgba32()
     {
         // arrange
-        var bgr1 = default(Bgr565);
-        var bgr2 = default(Bgr565);
-        ushort expected1 = ushort.MaxValue;
-        ushort expected2 = ushort.MaxValue;
+        const ushort expected1 = ushort.MaxValue;
+        const ushort expected2 = ushort.MaxValue;
 
         // act
-        bgr1.FromRgba32(new Rgba32(1.0f, 1.0f, 1.0f, 1.0f));
-        bgr2.FromRgba32(new Rgba32(1.0f, 1.0f, 1.0f, 0.0f));
+        Bgr565 bgr1 = Bgr565.FromRgba32(new Rgba32(1.0f, 1.0f, 1.0f, 1.0f));
+        Bgr565 bgr2 = Bgr565.FromRgba32(new Rgba32(1.0f, 1.0f, 1.0f, 0.0f));
 
         // assert
         Assert.Equal(expected1, bgr1.PackedValue);
@@ -148,12 +143,11 @@ public class Bgr565Tests
     public void Bgr565_ToRgba32()
     {
         // arrange
-        var bgra = new Bgr565(Vector3.One);
-        var expected = new Rgba32(Vector4.One);
-        var actual = default(Rgba32);
+        Bgr565 pixel = new(Vector3.One);
+        Rgba32 expected = new(Vector4.One);
 
         // act
-        bgra.ToRgba32(ref actual);
+        Rgba32 actual = pixel.ToRgba32();
 
         Assert.Equal(expected, actual);
     }
@@ -162,11 +156,10 @@ public class Bgr565Tests
     public void Bgra565_FromRgb48()
     {
         // arrange
-        var bgr = default(Bgr565);
-        ushort expectedPackedValue = ushort.MaxValue;
+        const ushort expectedPackedValue = ushort.MaxValue;
 
         // act
-        bgr.FromRgb48(new Rgb48(ushort.MaxValue, ushort.MaxValue, ushort.MaxValue));
+        Bgr565 bgr = Bgr565.FromRgb48(new Rgb48(ushort.MaxValue, ushort.MaxValue, ushort.MaxValue));
 
         // assert
         Assert.Equal(expectedPackedValue, bgr.PackedValue);
@@ -176,11 +169,10 @@ public class Bgr565Tests
     public void Bgra565_FromRgba64()
     {
         // arrange
-        var bgr = default(Bgr565);
-        ushort expectedPackedValue = ushort.MaxValue;
+        const ushort expectedPackedValue = ushort.MaxValue;
 
         // act
-        bgr.FromRgba64(new Rgba64(ushort.MaxValue, ushort.MaxValue, ushort.MaxValue, ushort.MaxValue));
+        Bgr565 bgr = Bgr565.FromRgba64(new Rgba64(ushort.MaxValue, ushort.MaxValue, ushort.MaxValue, ushort.MaxValue));
 
         // assert
         Assert.Equal(expectedPackedValue, bgr.PackedValue);
@@ -190,11 +182,10 @@ public class Bgr565Tests
     public void Bgr565_FromBgr24()
     {
         // arrange
-        var bgr = default(Bgr565);
-        ushort expected = ushort.MaxValue;
+        const ushort expected = ushort.MaxValue;
 
         // act
-        bgr.FromBgr24(new Bgr24(byte.MaxValue, byte.MaxValue, byte.MaxValue));
+        Bgr565 bgr = Bgr565.FromBgr24(new Bgr24(byte.MaxValue, byte.MaxValue, byte.MaxValue));
 
         // assert
         Assert.Equal(expected, bgr.PackedValue);
@@ -204,11 +195,10 @@ public class Bgr565Tests
     public void Bgr565_FromRgb24()
     {
         // arrange
-        var bgr = default(Bgr565);
-        ushort expected = ushort.MaxValue;
+        const ushort expected = ushort.MaxValue;
 
         // act
-        bgr.FromRgb24(new Rgb24(byte.MaxValue, byte.MaxValue, byte.MaxValue));
+        Bgr565 bgr = Bgr565.FromRgb24(new Rgb24(byte.MaxValue, byte.MaxValue, byte.MaxValue));
 
         // assert
         Assert.Equal(expected, bgr.PackedValue);
@@ -218,11 +208,10 @@ public class Bgr565Tests
     public void Bgr565_FromGrey8()
     {
         // arrange
-        var bgr = default(Bgr565);
-        ushort expected = ushort.MaxValue;
+        const ushort expected = ushort.MaxValue;
 
         // act
-        bgr.FromL8(new L8(byte.MaxValue));
+        Bgr565 bgr = Bgr565.FromL8(new L8(byte.MaxValue));
 
         // assert
         Assert.Equal(expected, bgr.PackedValue);
@@ -232,11 +221,10 @@ public class Bgr565Tests
     public void Bgr565_FromGrey16()
     {
         // arrange
-        var bgr = default(Bgr565);
-        ushort expected = ushort.MaxValue;
+        const ushort expected = ushort.MaxValue;
 
         // act
-        bgr.FromL16(new L16(ushort.MaxValue));
+        Bgr565 bgr = Bgr565.FromL16(new L16(ushort.MaxValue));
 
         // assert
         Assert.Equal(expected, bgr.PackedValue);
@@ -248,4 +236,21 @@ public class Bgr565Tests
         Assert.Equal(Vector3.Zero, new Bgr565(Vector3.One * -1234F).ToVector3());
         Assert.Equal(Vector3.One, new Bgr565(Vector3.One * 1234F).ToVector3());
     }
+
+    [Fact]
+    public void Bgr565_PixelInformation()
+    {
+        PixelTypeInfo info = Bgr565.GetPixelTypeInfo();
+        Assert.Equal(Unsafe.SizeOf<Bgr565>() * 8, info.BitsPerPixel);
+        Assert.Equal(PixelAlphaRepresentation.None, info.AlphaRepresentation);
+        Assert.Equal(PixelColorType.BGR, info.ColorType);
+
+        PixelComponentInfo componentInfo = info.ComponentInfo.Value;
+        Assert.Equal(3, componentInfo.ComponentCount);
+        Assert.Equal(0, componentInfo.Padding);
+        Assert.Equal(5, componentInfo.GetComponentPrecision(0));
+        Assert.Equal(6, componentInfo.GetComponentPrecision(1));
+        Assert.Equal(5, componentInfo.GetComponentPrecision(2));
+        Assert.Equal(6, componentInfo.GetMaximumComponentPrecision());
+    }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/Bgra32Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Bgra32Tests.cs
index 04c8813d5..277975896 100644
--- a/tests/ImageSharp.Tests/PixelFormats/Bgra32Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/Bgra32Tests.cs
@@ -2,6 +2,7 @@
 // Licensed under the Six Labors Split License.
 
 using System.Numerics;
+using System.Runtime.CompilerServices;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Tests.PixelFormats;
@@ -15,8 +16,8 @@ public class Bgra32Tests
     [Fact]
     public void AreEqual()
     {
-        var color1 = new Bgra32(byte.MaxValue, byte.MaxValue, byte.MaxValue, byte.MaxValue);
-        var color2 = new Bgra32(byte.MaxValue, byte.MaxValue, byte.MaxValue);
+        Bgra32 color1 = new(byte.MaxValue, byte.MaxValue, byte.MaxValue, byte.MaxValue);
+        Bgra32 color2 = new(byte.MaxValue, byte.MaxValue, byte.MaxValue);
 
         Assert.Equal(color1, color2);
     }
@@ -27,8 +28,8 @@ public class Bgra32Tests
     [Fact]
     public void AreNotEqual()
     {
-        var color1 = new Bgra32(0, 0, byte.MaxValue, byte.MaxValue);
-        var color2 = new Bgra32(byte.MaxValue, byte.MaxValue, byte.MaxValue);
+        Bgra32 color1 = new(0, 0, byte.MaxValue, byte.MaxValue);
+        Bgra32 color2 = new(byte.MaxValue, byte.MaxValue, byte.MaxValue);
 
         Assert.NotEqual(color1, color2);
     }
@@ -46,7 +47,7 @@ public class Bgra32Tests
     [MemberData(nameof(ColorData))]
     public void Constructor(byte b, byte g, byte r, byte a)
     {
-        var p = new Bgra32(r, g, b, a);
+        Bgra32 p = new(r, g, b, a);
 
         Assert.Equal(r, p.R);
         Assert.Equal(g, p.G);
@@ -57,7 +58,7 @@ public class Bgra32Tests
     [Fact]
     public unsafe void ByteLayoutIsSequentialBgra()
     {
-        var color = new Bgra32(1, 2, 3, 4);
+        Bgra32 color = new(1, 2, 3, 4);
         byte* ptr = (byte*)&color;
 
         Assert.Equal(3, ptr[0]);
@@ -70,8 +71,8 @@ public class Bgra32Tests
     [MemberData(nameof(ColorData))]
     public void Equality_WhenTrue(byte b, byte g, byte r, byte a)
     {
-        var x = new Bgra32(r, g, b, a);
-        var y = new Bgra32(r, g, b, a);
+        Bgra32 x = new(r, g, b, a);
+        Bgra32 y = new(r, g, b, a);
 
         Assert.True(x.Equals(y));
         Assert.True(x.Equals((object)y));
@@ -85,8 +86,8 @@ public class Bgra32Tests
     [InlineData(1, 255, 0, 0, 0, 255, 0, 0)]
     public void Equality_WhenFalse(byte b1, byte g1, byte r1, byte a1, byte b2, byte g2, byte r2, byte a2)
     {
-        var x = new Bgra32(r1, g1, b1, a1);
-        var y = new Bgra32(r2, g2, b2, a2);
+        Bgra32 x = new(r1, g1, b1, a1);
+        Bgra32 y = new(r2, g2, b2, a2);
 
         Assert.False(x.Equals(y));
         Assert.False(x.Equals((object)y));
@@ -95,8 +96,7 @@ public class Bgra32Tests
     [Fact]
     public void FromRgba32()
     {
-        var bgra = default(Bgra32);
-        bgra.FromRgba32(new Rgba32(1, 2, 3, 4));
+        Bgra32 bgra = Bgra32.FromRgba32(new Rgba32(1, 2, 3, 4));
 
         Assert.Equal(1, bgra.R);
         Assert.Equal(2, bgra.G);
@@ -104,7 +104,7 @@ public class Bgra32Tests
         Assert.Equal(4, bgra.A);
     }
 
-    private static Vector4 Vec(byte r, byte g, byte b, byte a = 255) => new Vector4(
+    private static Vector4 Vec(byte r, byte g, byte b, byte a = 255) => new(
         r / 255f,
         g / 255f,
         b / 255f,
@@ -113,8 +113,7 @@ public class Bgra32Tests
     [Fact]
     public void FromVector4()
     {
-        var c = default(Bgra32);
-        c.FromVector4(Vec(1, 2, 3, 4));
+        Bgra32 c = Bgra32.FromVector4(Vec(1, 2, 3, 4));
 
         Assert.Equal(1, c.R);
         Assert.Equal(2, c.G);
@@ -125,7 +124,7 @@ public class Bgra32Tests
     [Fact]
     public void ToVector4()
     {
-        var rgb = new Bgra32(1, 2, 3, 4);
+        Bgra32 rgb = new(1, 2, 3, 4);
 
         Assert.Equal(Vec(1, 2, 3, 4), rgb.ToVector4());
     }
@@ -134,13 +133,30 @@ public class Bgra32Tests
     public void Bgra32_FromBgra5551()
     {
         // arrange
-        var bgra = default(Bgra32);
-        uint expected = uint.MaxValue;
+        const uint expected = uint.MaxValue;
 
         // act
-        bgra.FromBgra5551(new Bgra5551(1.0f, 1.0f, 1.0f, 1.0f));
+        Bgra32 bgra = Bgra32.FromBgra5551(new Bgra5551(1.0f, 1.0f, 1.0f, 1.0f));
 
         // assert
         Assert.Equal(expected, bgra.PackedValue);
     }
+
+    [Fact]
+    public void Bgra32_PixelInformation()
+    {
+        PixelTypeInfo info = Bgra32.GetPixelTypeInfo();
+        Assert.Equal(Unsafe.SizeOf<Bgra32>() * 8, info.BitsPerPixel);
+        Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
+        Assert.Equal(PixelColorType.BGR | PixelColorType.Alpha, info.ColorType);
+
+        PixelComponentInfo componentInfo = info.ComponentInfo.Value;
+        Assert.Equal(4, componentInfo.ComponentCount);
+        Assert.Equal(0, componentInfo.Padding);
+        Assert.Equal(8, componentInfo.GetComponentPrecision(0));
+        Assert.Equal(8, componentInfo.GetComponentPrecision(1));
+        Assert.Equal(8, componentInfo.GetComponentPrecision(2));
+        Assert.Equal(8, componentInfo.GetComponentPrecision(3));
+        Assert.Equal(8, componentInfo.GetMaximumComponentPrecision());
+    }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/Bgra4444Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Bgra4444Tests.cs
index 543b5814f..5d20b5cf1 100644
--- a/tests/ImageSharp.Tests/PixelFormats/Bgra4444Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/Bgra4444Tests.cs
@@ -2,6 +2,7 @@
 // Licensed under the Six Labors Split License.
 
 using System.Numerics;
+using System.Runtime.CompilerServices;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Tests.PixelFormats;
@@ -15,10 +16,10 @@ public class Bgra4444Tests
     [Fact]
     public void AreEqual()
     {
-        var color1 = new Bgra4444(0.0f, 0.0f, 0.0f, 0.0f);
-        var color2 = new Bgra4444(new Vector4(0.0f));
-        var color3 = new Bgra4444(new Vector4(1.0f, 0.0f, 1.0f, 1.0f));
-        var color4 = new Bgra4444(1.0f, 0.0f, 1.0f, 1.0f);
+        Bgra4444 color1 = new(0.0f, 0.0f, 0.0f, 0.0f);
+        Bgra4444 color2 = new(new Vector4(0.0f));
+        Bgra4444 color3 = new(new Vector4(1.0f, 0.0f, 1.0f, 1.0f));
+        Bgra4444 color4 = new(1.0f, 0.0f, 1.0f, 1.0f);
 
         Assert.Equal(color1, color2);
         Assert.Equal(color3, color4);
@@ -30,10 +31,10 @@ public class Bgra4444Tests
     [Fact]
     public void AreNotEqual()
     {
-        var color1 = new Bgra4444(0.0f, 0.0f, 0.0f, 0.0f);
-        var color2 = new Bgra4444(new Vector4(1.0f));
-        var color3 = new Bgra4444(new Vector4(1.0f, 0.0f, 0.0f, 1.0f));
-        var color4 = new Bgra4444(1.0f, 1.0f, 0.0f, 1.0f);
+        Bgra4444 color1 = new(0.0f, 0.0f, 0.0f, 0.0f);
+        Bgra4444 color2 = new(new Vector4(1.0f));
+        Bgra4444 color3 = new(new Vector4(1.0f, 0.0f, 0.0f, 1.0f));
+        Bgra4444 color4 = new(1.0f, 1.0f, 0.0f, 1.0f);
 
         Assert.NotEqual(color1, color2);
         Assert.NotEqual(color3, color4);
@@ -66,10 +67,10 @@ public class Bgra4444Tests
     public void Bgra4444_ToScaledVector4()
     {
         // arrange
-        var bgra = new Bgra4444(Vector4.One);
+        Bgra4444 pixel = new(Vector4.One);
 
         // act
-        Vector4 actual = bgra.ToScaledVector4();
+        Vector4 actual = pixel.ToScaledVector4();
 
         // assert
         Assert.Equal(1, actual.X);
@@ -82,12 +83,11 @@ public class Bgra4444Tests
     public void Bgra4444_ToRgba32()
     {
         // arrange
-        var bgra = new Bgra4444(Vector4.One);
-        var expected = new Rgba32(Vector4.One);
-        var actual = default(Rgba32);
+        Bgra4444 pixel = new(Vector4.One);
+        Rgba32 expected = new(Vector4.One);
 
         // act
-        bgra.ToRgba32(ref actual);
+        Rgba32 actual = pixel.ToRgba32();
 
         Assert.Equal(expected, actual);
     }
@@ -97,12 +97,11 @@ public class Bgra4444Tests
     {
         // arrange
         Vector4 scaled = new Bgra4444(Vector4.One).ToScaledVector4();
-        int expected = 0xFFFF;
-        var bgra = default(Bgra4444);
+        const int expected = 0xFFFF;
 
         // act
-        bgra.FromScaledVector4(scaled);
-        ushort actual = bgra.PackedValue;
+        Bgra4444 pixel = Bgra4444.FromScaledVector4(scaled);
+        ushort actual = pixel.PackedValue;
 
         // assert
         Assert.Equal(expected, actual);
@@ -112,42 +111,38 @@ public class Bgra4444Tests
     public void Bgra4444_FromBgra5551()
     {
         // arrange
-        var bgra = default(Bgra4444);
-        ushort expected = ushort.MaxValue;
+        const ushort expected = ushort.MaxValue;
 
         // act
-        bgra.FromBgra5551(new Bgra5551(1.0f, 1.0f, 1.0f, 1.0f));
+        Bgra4444 pixel = Bgra4444.FromBgra5551(new Bgra5551(1.0f, 1.0f, 1.0f, 1.0f));
 
         // assert
-        Assert.Equal(expected, bgra.PackedValue);
+        Assert.Equal(expected, pixel.PackedValue);
     }
 
     [Fact]
     public void Bgra4444_FromArgb32()
     {
         // arrange
-        var bgra = default(Bgra4444);
-        ushort expectedPackedValue = ushort.MaxValue;
+        const ushort expectedPackedValue = ushort.MaxValue;
 
         // act
-        bgra.FromArgb32(new Argb32(255, 255, 255, 255));
+        Bgra4444 pixel = Bgra4444.FromArgb32(new Argb32(255, 255, 255, 255));
 
         // assert
-        Assert.Equal(expectedPackedValue, bgra.PackedValue);
+        Assert.Equal(expectedPackedValue, pixel.PackedValue);
     }
 
     [Fact]
     public void Bgra4444_FromRgba32()
     {
         // arrange
-        var bgra1 = default(Bgra4444);
-        var bgra2 = default(Bgra4444);
-        ushort expectedPackedValue1 = ushort.MaxValue;
-        ushort expectedPackedValue2 = 0xFF0F;
+        const ushort expectedPackedValue1 = ushort.MaxValue;
+        const ushort expectedPackedValue2 = 0xFF0F;
 
         // act
-        bgra1.FromRgba32(new Rgba32(255, 255, 255, 255));
-        bgra2.FromRgba32(new Rgba32(255, 0, 255, 255));
+        Bgra4444 bgra1 = Bgra4444.FromRgba32(new Rgba32(255, 255, 255, 255));
+        Bgra4444 bgra2 = Bgra4444.FromRgba32(new Rgba32(255, 0, 255, 255));
 
         // assert
         Assert.Equal(expectedPackedValue1, bgra1.PackedValue);
@@ -158,84 +153,78 @@ public class Bgra4444Tests
     public void Bgra4444_FromRgb48()
     {
         // arrange
-        var bgra = default(Bgra4444);
-        ushort expectedPackedValue = ushort.MaxValue;
+        const ushort expectedPackedValue = ushort.MaxValue;
 
         // act
-        bgra.FromRgb48(new Rgb48(ushort.MaxValue, ushort.MaxValue, ushort.MaxValue));
+        Bgra4444 pixel = Bgra4444.FromRgb48(new Rgb48(ushort.MaxValue, ushort.MaxValue, ushort.MaxValue));
 
         // assert
-        Assert.Equal(expectedPackedValue, bgra.PackedValue);
+        Assert.Equal(expectedPackedValue, pixel.PackedValue);
     }
 
     [Fact]
     public void Bgra4444_FromRgba64()
     {
         // arrange
-        var bgra = default(Bgra4444);
-        ushort expectedPackedValue = ushort.MaxValue;
+        const ushort expectedPackedValue = ushort.MaxValue;
 
         // act
-        bgra.FromRgba64(new Rgba64(ushort.MaxValue, ushort.MaxValue, ushort.MaxValue, ushort.MaxValue));
+        Bgra4444 pixel = Bgra4444.FromRgba64(new Rgba64(ushort.MaxValue, ushort.MaxValue, ushort.MaxValue, ushort.MaxValue));
 
         // assert
-        Assert.Equal(expectedPackedValue, bgra.PackedValue);
+        Assert.Equal(expectedPackedValue, pixel.PackedValue);
     }
 
     [Fact]
     public void Bgra4444_FromGrey16()
     {
         // arrange
-        var bgra = default(Bgra4444);
-        ushort expectedPackedValue = ushort.MaxValue;
+        const ushort expectedPackedValue = ushort.MaxValue;
 
         // act
-        bgra.FromL16(new L16(ushort.MaxValue));
+        Bgra4444 pixel = Bgra4444.FromL16(new L16(ushort.MaxValue));
 
         // assert
-        Assert.Equal(expectedPackedValue, bgra.PackedValue);
+        Assert.Equal(expectedPackedValue, pixel.PackedValue);
     }
 
     [Fact]
     public void Bgra4444_FromGrey8()
     {
         // arrange
-        var bgra = default(Bgra4444);
-        ushort expectedPackedValue = ushort.MaxValue;
+        const ushort expectedPackedValue = ushort.MaxValue;
 
         // act
-        bgra.FromL8(new L8(byte.MaxValue));
+        Bgra4444 pixel = Bgra4444.FromL8(new L8(byte.MaxValue));
 
         // assert
-        Assert.Equal(expectedPackedValue, bgra.PackedValue);
+        Assert.Equal(expectedPackedValue, pixel.PackedValue);
     }
 
     [Fact]
     public void Bgra4444_FromBgr24()
     {
         // arrange
-        var bgra = default(Bgra4444);
-        ushort expectedPackedValue = ushort.MaxValue;
+        const ushort expectedPackedValue = ushort.MaxValue;
 
         // act
-        bgra.FromBgr24(new Bgr24(byte.MaxValue, byte.MaxValue, byte.MaxValue));
+        Bgra4444 pixel = Bgra4444.FromBgr24(new Bgr24(byte.MaxValue, byte.MaxValue, byte.MaxValue));
 
         // assert
-        Assert.Equal(expectedPackedValue, bgra.PackedValue);
+        Assert.Equal(expectedPackedValue, pixel.PackedValue);
     }
 
     [Fact]
     public void Bgra4444_FromRgb24()
     {
         // arrange
-        var bgra = default(Bgra4444);
-        ushort expectedPackedValue = ushort.MaxValue;
+        const ushort expectedPackedValue = ushort.MaxValue;
 
         // act
-        bgra.FromRgb24(new Rgb24(byte.MaxValue, byte.MaxValue, byte.MaxValue));
+        Bgra4444 pixel = Bgra4444.FromRgb24(new Rgb24(byte.MaxValue, byte.MaxValue, byte.MaxValue));
 
         // assert
-        Assert.Equal(expectedPackedValue, bgra.PackedValue);
+        Assert.Equal(expectedPackedValue, pixel.PackedValue);
     }
 
     [Fact]
@@ -244,4 +233,22 @@ public class Bgra4444Tests
         Assert.Equal(Vector4.Zero, new Bgra4444(Vector4.One * -1234.0f).ToVector4());
         Assert.Equal(Vector4.One, new Bgra4444(Vector4.One * 1234.0f).ToVector4());
     }
+
+    [Fact]
+    public void Bgra4444_PixelInformation()
+    {
+        PixelTypeInfo info = Bgra4444.GetPixelTypeInfo();
+        Assert.Equal(Unsafe.SizeOf<Bgra4444>() * 8, info.BitsPerPixel);
+        Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
+        Assert.Equal(PixelColorType.BGR | PixelColorType.Alpha, info.ColorType);
+
+        PixelComponentInfo componentInfo = info.ComponentInfo.Value;
+        Assert.Equal(4, componentInfo.ComponentCount);
+        Assert.Equal(0, componentInfo.Padding);
+        Assert.Equal(4, componentInfo.GetComponentPrecision(0));
+        Assert.Equal(4, componentInfo.GetComponentPrecision(1));
+        Assert.Equal(4, componentInfo.GetComponentPrecision(2));
+        Assert.Equal(4, componentInfo.GetComponentPrecision(3));
+        Assert.Equal(4, componentInfo.GetMaximumComponentPrecision());
+    }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/Bgra5551Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Bgra5551Tests.cs
index ec5417310..38f809e49 100644
--- a/tests/ImageSharp.Tests/PixelFormats/Bgra5551Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/Bgra5551Tests.cs
@@ -2,6 +2,7 @@
 // Licensed under the Six Labors Split License.
 
 using System.Numerics;
+using System.Runtime.CompilerServices;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Tests.PixelFormats;
@@ -15,10 +16,10 @@ public class Bgra5551Tests
     [Fact]
     public void AreEqual()
     {
-        var color1 = new Bgra5551(0.0f, 0.0f, 0.0f, 0.0f);
-        var color2 = new Bgra5551(new Vector4(0.0f));
-        var color3 = new Bgra5551(new Vector4(1.0f, 0.0f, 0.0f, 1.0f));
-        var color4 = new Bgra5551(1.0f, 0.0f, 0.0f, 1.0f);
+        Bgra5551 color1 = new(0.0f, 0.0f, 0.0f, 0.0f);
+        Bgra5551 color2 = new(new Vector4(0.0f));
+        Bgra5551 color3 = new(new Vector4(1f, 0.0f, 0.0f, 1f));
+        Bgra5551 color4 = new(1f, 0.0f, 0.0f, 1f);
 
         Assert.Equal(color1, color2);
         Assert.Equal(color3, color4);
@@ -30,10 +31,10 @@ public class Bgra5551Tests
     [Fact]
     public void AreNotEqual()
     {
-        var color1 = new Bgra5551(0.0f, 0.0f, 0.0f, 0.0f);
-        var color2 = new Bgra5551(new Vector4(1.0f));
-        var color3 = new Bgra5551(new Vector4(1.0f, 0.0f, 0.0f, 1.0f));
-        var color4 = new Bgra5551(1.0f, 1.0f, 0.0f, 1.0f);
+        Bgra5551 color1 = new(0.0f, 0.0f, 0.0f, 0.0f);
+        Bgra5551 color2 = new(new Vector4(1f));
+        Bgra5551 color3 = new(new Vector4(1f, 0.0f, 0.0f, 1f));
+        Bgra5551 color4 = new(1f, 1f, 0.0f, 1f);
 
         Assert.NotEqual(color1, color2);
         Assert.NotEqual(color3, color4);
@@ -42,10 +43,10 @@ public class Bgra5551Tests
     [Fact]
     public void Bgra5551_PackedValue()
     {
-        float x = 0x1a;
-        float y = 0x16;
-        float z = 0xd;
-        float w = 0x1;
+        const float x = 0x1a;
+        const float y = 0x16;
+        const float z = 0xd;
+        const float w = 0x1;
         Assert.Equal(0xeacd, new Bgra5551(x / 0x1f, y / 0x1f, z / 0x1f, w).PackedValue);
         Assert.Equal(3088, new Bgra5551(0.1f, -0.3f, 0.5f, -0.7f).PackedValue);
 
@@ -71,10 +72,10 @@ public class Bgra5551Tests
     public void Bgra5551_ToScaledVector4()
     {
         // arrange
-        var bgra = new Bgra5551(Vector4.One);
+        Bgra5551 pixel = new(Vector4.One);
 
         // act
-        Vector4 actual = bgra.ToScaledVector4();
+        Vector4 actual = pixel.ToScaledVector4();
 
         // assert
         Assert.Equal(1, actual.X);
@@ -87,12 +88,11 @@ public class Bgra5551Tests
     public void Bgra5551_ToRgba32()
     {
         // arrange
-        var bgra = new Bgra5551(Vector4.One);
-        var expected = new Rgba32(Vector4.One);
-        var actual = default(Rgba32);
+        Bgra5551 pixel = new(Vector4.One);
+        Rgba32 expected = new(Vector4.One);
 
         // act
-        bgra.ToRgba32(ref actual);
+        Rgba32 actual = pixel.ToRgba32();
 
         Assert.Equal(expected, actual);
     }
@@ -102,11 +102,10 @@ public class Bgra5551Tests
     {
         // arrange
         Vector4 scaled = new Bgra5551(Vector4.One).ToScaledVector4();
-        int expected = 0xFFFF;
-        var pixel = default(Bgra5551);
+        const int expected = 0xFFFF;
 
         // act
-        pixel.FromScaledVector4(scaled);
+        Bgra5551 pixel = Bgra5551.FromScaledVector4(scaled);
         ushort actual = pixel.PackedValue;
 
         // assert
@@ -117,13 +116,11 @@ public class Bgra5551Tests
     public void Bgra5551_FromBgra5551()
     {
         // arrange
-        var bgra = default(Bgra5551);
-        var actual = default(Bgra5551);
-        var expected = new Bgra5551(1.0f, 0.0f, 1.0f, 1.0f);
+        Bgra5551 expected = new(1f, 0.0f, 1f, 1f);
 
         // act
-        bgra.FromBgra5551(expected);
-        actual.FromBgra5551(bgra);
+        Bgra5551 pixel = Bgra5551.FromBgra5551(expected);
+        Bgra5551 actual = Bgra5551.FromBgra5551(pixel);
 
         // assert
         Assert.Equal(expected, actual);
@@ -133,14 +130,12 @@ public class Bgra5551Tests
     public void Bgra5551_FromRgba32()
     {
         // arrange
-        var bgra1 = default(Bgra5551);
-        var bgra2 = default(Bgra5551);
-        ushort expectedPackedValue1 = ushort.MaxValue;
-        ushort expectedPackedValue2 = 0xFC1F;
+        const ushort expectedPackedValue1 = ushort.MaxValue;
+        const ushort expectedPackedValue2 = 0xFC1F;
 
         // act
-        bgra1.FromRgba32(new Rgba32(255, 255, 255, 255));
-        bgra2.FromRgba32(new Rgba32(255, 0, 255, 255));
+        Bgra5551 bgra1 = Bgra5551.FromRgba32(new Rgba32(255, 255, 255, 255));
+        Bgra5551 bgra2 = Bgra5551.FromRgba32(new Rgba32(255, 0, 255, 255));
 
         // assert
         Assert.Equal(expectedPackedValue1, bgra1.PackedValue);
@@ -151,14 +146,12 @@ public class Bgra5551Tests
     public void Bgra5551_FromBgra32()
     {
         // arrange
-        var bgra1 = default(Bgra5551);
-        var bgra2 = default(Bgra5551);
-        ushort expectedPackedValue1 = ushort.MaxValue;
-        ushort expectedPackedValue2 = 0xFC1F;
+        const ushort expectedPackedValue1 = ushort.MaxValue;
+        const ushort expectedPackedValue2 = 0xFC1F;
 
         // act
-        bgra1.FromBgra32(new Bgra32(255, 255, 255, 255));
-        bgra2.FromBgra32(new Bgra32(255, 0, 255, 255));
+        Bgra5551 bgra1 = Bgra5551.FromBgra32(new Bgra32(255, 255, 255, 255));
+        Bgra5551 bgra2 = Bgra5551.FromBgra32(new Bgra32(255, 0, 255, 255));
 
         // assert
         Assert.Equal(expectedPackedValue1, bgra1.PackedValue);
@@ -169,98 +162,91 @@ public class Bgra5551Tests
     public void Bgra5551_FromArgb32()
     {
         // arrange
-        var bgra = default(Bgra5551);
-        ushort expectedPackedValue = ushort.MaxValue;
+        const ushort expectedPackedValue = ushort.MaxValue;
 
         // act
-        bgra.FromArgb32(new Argb32(255, 255, 255, 255));
+        Bgra5551 pixel = Bgra5551.FromArgb32(new Argb32(255, 255, 255, 255));
 
         // assert
-        Assert.Equal(expectedPackedValue, bgra.PackedValue);
+        Assert.Equal(expectedPackedValue, pixel.PackedValue);
     }
 
     [Fact]
     public void Bgra5551_FromRgb48()
     {
         // arrange
-        var bgra = default(Bgra5551);
-        ushort expectedPackedValue = ushort.MaxValue;
+        const ushort expectedPackedValue = ushort.MaxValue;
 
         // act
-        bgra.FromRgb48(new Rgb48(ushort.MaxValue, ushort.MaxValue, ushort.MaxValue));
+        Bgra5551 pixel = Bgra5551.FromRgb48(new Rgb48(ushort.MaxValue, ushort.MaxValue, ushort.MaxValue));
 
         // assert
-        Assert.Equal(expectedPackedValue, bgra.PackedValue);
+        Assert.Equal(expectedPackedValue, pixel.PackedValue);
     }
 
     [Fact]
     public void Bgra5551_FromRgba64()
     {
         // arrange
-        var bgra = default(Bgra5551);
-        ushort expectedPackedValue = ushort.MaxValue;
+        const ushort expectedPackedValue = ushort.MaxValue;
 
         // act
-        bgra.FromRgba64(new Rgba64(ushort.MaxValue, ushort.MaxValue, ushort.MaxValue, ushort.MaxValue));
+        Bgra5551 pixel = Bgra5551.FromRgba64(new Rgba64(ushort.MaxValue, ushort.MaxValue, ushort.MaxValue, ushort.MaxValue));
 
         // assert
-        Assert.Equal(expectedPackedValue, bgra.PackedValue);
+        Assert.Equal(expectedPackedValue, pixel.PackedValue);
     }
 
     [Fact]
     public void Bgra5551_FromGrey16()
     {
         // arrange
-        var bgra = default(Bgra5551);
-        ushort expectedPackedValue = ushort.MaxValue;
+        const ushort expectedPackedValue = ushort.MaxValue;
 
         // act
-        bgra.FromL16(new L16(ushort.MaxValue));
+        Bgra5551 pixel = Bgra5551.FromL16(new L16(ushort.MaxValue));
 
         // assert
-        Assert.Equal(expectedPackedValue, bgra.PackedValue);
+        Assert.Equal(expectedPackedValue, pixel.PackedValue);
     }
 
     [Fact]
     public void Bgra5551_FromGrey8()
     {
         // arrange
-        var bgra = default(Bgra5551);
-        ushort expectedPackedValue = ushort.MaxValue;
+        const ushort expectedPackedValue = ushort.MaxValue;
 
         // act
-        bgra.FromL8(new L8(byte.MaxValue));
+        Bgra5551 pixel = Bgra5551.FromL8(new L8(byte.MaxValue));
 
         // assert
-        Assert.Equal(expectedPackedValue, bgra.PackedValue);
+        Assert.Equal(expectedPackedValue, pixel.PackedValue);
     }
 
     [Fact]
     public void Bgra5551_FromBgr24()
     {
         // arrange
-        var bgra = default(Bgra5551);
-        ushort expectedPackedValue = ushort.MaxValue;
+        const ushort expectedPackedValue = ushort.MaxValue;
 
         // act
-        bgra.FromBgr24(new Bgr24(byte.MaxValue, byte.MaxValue, byte.MaxValue));
+        Bgra5551 pixel = Bgra5551.FromBgr24(new Bgr24(byte.MaxValue, byte.MaxValue, byte.MaxValue));
 
         // assert
-        Assert.Equal(expectedPackedValue, bgra.PackedValue);
+        Assert.Equal(expectedPackedValue, pixel.PackedValue);
     }
 
     [Fact]
     public void Bgra5551_FromRgb24()
     {
         // arrange
-        var bgra = default(Bgra5551);
-        ushort expectedPackedValue = ushort.MaxValue;
+        const ushort expectedPackedValue = ushort.MaxValue;
 
         // act
-        bgra.FromRgb24(new Rgb24(byte.MaxValue, byte.MaxValue, byte.MaxValue));
+        Bgra5551 pixel = Bgra5551.FromRgb24(new Rgb24(byte.MaxValue, byte.MaxValue, byte.MaxValue));
 
         // assert
-        Assert.Equal(expectedPackedValue, bgra.PackedValue);
+        Assert.Equal(expectedPackedValue, pixel.PackedValue);
     }
 
     [Fact]
@@ -269,4 +255,22 @@ public class Bgra5551Tests
         Assert.Equal(Vector4.Zero, new Bgra5551(Vector4.One * -1234.0f).ToVector4());
         Assert.Equal(Vector4.One, new Bgra5551(Vector4.One * 1234.0f).ToVector4());
     }
+
+    [Fact]
+    public void Bgra5551_PixelInformation()
+    {
+        PixelTypeInfo info = Bgra5551.GetPixelTypeInfo();
+        Assert.Equal(Unsafe.SizeOf<Bgra5551>() * 8, info.BitsPerPixel);
+        Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
+        Assert.Equal(PixelColorType.BGR | PixelColorType.Alpha, info.ColorType);
+
+        PixelComponentInfo componentInfo = info.ComponentInfo.Value;
+        Assert.Equal(4, componentInfo.ComponentCount);
+        Assert.Equal(0, componentInfo.Padding);
+        Assert.Equal(5, componentInfo.GetComponentPrecision(0));
+        Assert.Equal(5, componentInfo.GetComponentPrecision(1));
+        Assert.Equal(5, componentInfo.GetComponentPrecision(2));
+        Assert.Equal(1, componentInfo.GetComponentPrecision(3));
+        Assert.Equal(5, componentInfo.GetMaximumComponentPrecision());
+    }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/Byte4Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Byte4Tests.cs
index 435f07391..e73d64640 100644
--- a/tests/ImageSharp.Tests/PixelFormats/Byte4Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/Byte4Tests.cs
@@ -2,6 +2,7 @@
 // Licensed under the Six Labors Split License.
 
 using System.Numerics;
+using System.Runtime.CompilerServices;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Tests.PixelFormats;
@@ -15,10 +16,10 @@ public class Byte4Tests
     [Fact]
     public void AreEqual()
     {
-        var color1 = new Byte4(0.0f, 0.0f, 0.0f, 0.0f);
-        var color2 = new Byte4(new Vector4(0.0f));
-        var color3 = new Byte4(new Vector4(1.0f, 0.0f, 1.0f, 1.0f));
-        var color4 = new Byte4(1.0f, 0.0f, 1.0f, 1.0f);
+        Byte4 color1 = new(0f, 0f, 0f, 0f);
+        Byte4 color2 = new(new Vector4(0f));
+        Byte4 color3 = new(new Vector4(1f, 0f, 1f, 1f));
+        Byte4 color4 = new(1f, 0f, 1f, 1f);
 
         Assert.Equal(color1, color2);
         Assert.Equal(color3, color4);
@@ -30,10 +31,10 @@ public class Byte4Tests
     [Fact]
     public void AreNotEqual()
     {
-        var color1 = new Byte4(0.0f, 0.0f, 0.0f, 0.0f);
-        var color2 = new Byte4(new Vector4(1.0f));
-        var color3 = new Byte4(new Vector4(1.0f, 0.0f, 0.0f, 1.0f));
-        var color4 = new Byte4(1.0f, 1.0f, 0.0f, 1.0f);
+        Byte4 color1 = new(0f, 0f, 0f, 0f);
+        Byte4 color2 = new(new Vector4(1f));
+        Byte4 color3 = new(new Vector4(1f, 0f, 0f, 1f));
+        Byte4 color4 = new(1f, 1f, 0f, 1f);
 
         Assert.NotEqual(color1, color2);
         Assert.NotEqual(color3, color4);
@@ -63,10 +64,10 @@ public class Byte4Tests
     public void Byte4_ToScaledVector4()
     {
         // arrange
-        var byte4 = new Byte4(Vector4.One * 255);
+        Byte4 pixel = new(Vector4.One * 255);
 
         // act
-        Vector4 actual = byte4.ToScaledVector4();
+        Vector4 actual = pixel.ToScaledVector4();
 
         // assert
         Assert.Equal(1, actual.X);
@@ -79,12 +80,11 @@ public class Byte4Tests
     public void Byte4_ToRgba32()
     {
         // arrange
-        var byte4 = new Byte4(byte.MaxValue, byte.MaxValue, byte.MaxValue, byte.MaxValue);
-        var expected = new Rgba32(Vector4.One);
-        var actual = default(Rgba32);
+        Byte4 pixel = new(byte.MaxValue, byte.MaxValue, byte.MaxValue, byte.MaxValue);
+        Rgba32 expected = new(Vector4.One);
 
         // act
-        byte4.ToRgba32(ref actual);
+        Rgba32 actual = pixel.ToRgba32();
 
         Assert.Equal(expected, actual);
     }
@@ -94,11 +94,10 @@ public class Byte4Tests
     {
         // arrange
         Vector4 scaled = new Byte4(Vector4.One * 255).ToScaledVector4();
-        var pixel = default(Byte4);
-        uint expected = 0xFFFFFFFF;
+        const uint expected = 0xFFFFFFFF;
 
         // act
-        pixel.FromScaledVector4(scaled);
+        Byte4 pixel = Byte4.FromScaledVector4(scaled);
         uint actual = pixel.PackedValue;
 
         // assert
@@ -109,126 +108,117 @@ public class Byte4Tests
     public void Byte4_FromArgb32()
     {
         // arrange
-        var byte4 = default(Byte4);
-        uint expectedPackedValue = uint.MaxValue;
+        const uint expectedPackedValue = uint.MaxValue;
 
         // act
-        byte4.FromArgb32(new Argb32(255, 255, 255, 255));
+        Byte4 pixel = Byte4.FromArgb32(new Argb32(255, 255, 255, 255));
 
         // assert
-        Assert.Equal(expectedPackedValue, byte4.PackedValue);
+        Assert.Equal(expectedPackedValue, pixel.PackedValue);
     }
 
     [Fact]
     public void Byte4_FromBgr24()
     {
         // arrange
-        var byte4 = default(Byte4);
-        uint expectedPackedValue = uint.MaxValue;
+        const uint expectedPackedValue = uint.MaxValue;
 
         // act
-        byte4.FromBgr24(new Bgr24(byte.MaxValue, byte.MaxValue, byte.MaxValue));
+        Byte4 pixel = Byte4.FromBgr24(new Bgr24(byte.MaxValue, byte.MaxValue, byte.MaxValue));
 
         // assert
-        Assert.Equal(expectedPackedValue, byte4.PackedValue);
+        Assert.Equal(expectedPackedValue, pixel.PackedValue);
     }
 
     [Fact]
     public void Byte4_FromGrey8()
     {
         // arrange
-        var byte4 = default(Byte4);
-        uint expectedPackedValue = uint.MaxValue;
+        const uint expectedPackedValue = uint.MaxValue;
 
         // act
-        byte4.FromL8(new L8(byte.MaxValue));
+        Byte4 pixel = Byte4.FromL8(new L8(byte.MaxValue));
 
         // assert
-        Assert.Equal(expectedPackedValue, byte4.PackedValue);
+        Assert.Equal(expectedPackedValue, pixel.PackedValue);
     }
 
     [Fact]
     public void Byte4_FromGrey16()
     {
         // arrange
-        var byte4 = default(Byte4);
-        uint expectedPackedValue = uint.MaxValue;
+        const uint expectedPackedValue = uint.MaxValue;
 
         // act
-        byte4.FromL16(new L16(ushort.MaxValue));
+        Byte4 pixel = Byte4.FromL16(new L16(ushort.MaxValue));
 
         // assert
-        Assert.Equal(expectedPackedValue, byte4.PackedValue);
+        Assert.Equal(expectedPackedValue, pixel.PackedValue);
     }
 
     [Fact]
     public void Byte4_FromRgb24()
     {
         // arrange
-        var byte4 = default(Byte4);
-        uint expectedPackedValue = uint.MaxValue;
+        const uint expectedPackedValue = uint.MaxValue;
 
         // act
-        byte4.FromRgb24(new Rgb24(byte.MaxValue, byte.MaxValue, byte.MaxValue));
+        Byte4 pixel = Byte4.FromRgb24(new Rgb24(byte.MaxValue, byte.MaxValue, byte.MaxValue));
 
         // assert
-        Assert.Equal(expectedPackedValue, byte4.PackedValue);
+        Assert.Equal(expectedPackedValue, pixel.PackedValue);
     }
 
     [Fact]
     public void Byte4_FromBgra5551()
     {
         // arrange
-        var byte4 = default(Byte4);
-        uint expected = 0xFFFFFFFF;
+        const uint expected = 0xFFFFFFFF;
 
         // act
-        byte4.FromBgra5551(new Bgra5551(1.0f, 1.0f, 1.0f, 1.0f));
+        Byte4 pixel = Byte4.FromBgra5551(new Bgra5551(1f, 1f, 1f, 1f));
 
         // assert
-        Assert.Equal(expected, byte4.PackedValue);
+        Assert.Equal(expected, pixel.PackedValue);
     }
 
     [Fact]
     public void Byte4_FromRgba32()
     {
         // arrange
-        var byte4 = default(Byte4);
-        uint expectedPackedValue1 = uint.MaxValue;
+        const uint expectedPackedValue1 = uint.MaxValue;
 
         // act
-        byte4.FromRgba32(new Rgba32(255, 255, 255, 255));
+        Byte4 pixel = Byte4.FromRgba32(new Rgba32(255, 255, 255, 255));
 
         // assert
-        Assert.Equal(expectedPackedValue1, byte4.PackedValue);
+        Assert.Equal(expectedPackedValue1, pixel.PackedValue);
     }
 
     [Fact]
     public void Byte4_FromRgb48()
     {
         // arrange
-        var byte4 = default(Byte4);
-        uint expectedPackedValue = uint.MaxValue;
+        const uint expectedPackedValue = uint.MaxValue;
 
         // act
-        byte4.FromRgb48(new Rgb48(ushort.MaxValue, ushort.MaxValue, ushort.MaxValue));
+        Byte4 pixel = Byte4.FromRgb48(new Rgb48(ushort.MaxValue, ushort.MaxValue, ushort.MaxValue));
 
         // assert
-        Assert.Equal(expectedPackedValue, byte4.PackedValue);
+        Assert.Equal(expectedPackedValue, pixel.PackedValue);
     }
 
     [Fact]
     public void Byte4_FromRgba64()
     {
         // arrange
-        var byte4 = default(Byte4);
-        uint expectedPackedValue = uint.MaxValue;
+        const uint expectedPackedValue = uint.MaxValue;
 
         // act
-        byte4.FromRgba64(new Rgba64(ushort.MaxValue, ushort.MaxValue, ushort.MaxValue, ushort.MaxValue));
+        Byte4 pixel = Byte4.FromRgba64(new Rgba64(ushort.MaxValue, ushort.MaxValue, ushort.MaxValue, ushort.MaxValue));
 
         // assert
-        Assert.Equal(expectedPackedValue, byte4.PackedValue);
+        Assert.Equal(expectedPackedValue, pixel.PackedValue);
     }
 
     [Fact]
@@ -237,4 +227,22 @@ public class Byte4Tests
         Assert.Equal(Vector4.Zero, new Byte4(Vector4.One * -1234.0f).ToVector4());
         Assert.Equal(Vector4.One * 255, new Byte4(Vector4.One * 1234.0f).ToVector4());
     }
+
+    [Fact]
+    public void Byte4_PixelInformation()
+    {
+        PixelTypeInfo info = Byte4.GetPixelTypeInfo();
+        Assert.Equal(Unsafe.SizeOf<Byte4>() * 8, info.BitsPerPixel);
+        Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
+        Assert.Equal(PixelColorType.RGB | PixelColorType.Alpha, info.ColorType);
+
+        PixelComponentInfo componentInfo = info.ComponentInfo.Value;
+        Assert.Equal(4, componentInfo.ComponentCount);
+        Assert.Equal(0, componentInfo.Padding);
+        Assert.Equal(8, componentInfo.GetComponentPrecision(0));
+        Assert.Equal(8, componentInfo.GetComponentPrecision(1));
+        Assert.Equal(8, componentInfo.GetComponentPrecision(2));
+        Assert.Equal(8, componentInfo.GetComponentPrecision(3));
+        Assert.Equal(8, componentInfo.GetMaximumComponentPrecision());
+    }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/HalfSingleTests.cs b/tests/ImageSharp.Tests/PixelFormats/HalfSingleTests.cs
index 9ffaf3e21..9366c51c9 100644
--- a/tests/ImageSharp.Tests/PixelFormats/HalfSingleTests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/HalfSingleTests.cs
@@ -2,6 +2,7 @@
 // Licensed under the Six Labors Split License.
 
 using System.Numerics;
+using System.Runtime.CompilerServices;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Tests.PixelFormats;
@@ -25,11 +26,11 @@ public class HalfSingleTests
     public void HalfSingle_ToVector4()
     {
         // arrange
-        var halfSingle = new HalfSingle(0.5f);
-        var expected = new Vector4(0.5f, 0, 0, 1);
+        HalfSingle pixel = new(0.5f);
+        Vector4 expected = new(0.5f, 0, 0, 1);
 
         // act
-        var actual = halfSingle.ToVector4();
+        Vector4 actual = pixel.ToVector4();
 
         // assert
         Assert.Equal(expected, actual);
@@ -39,10 +40,10 @@ public class HalfSingleTests
     public void HalfSingle_ToScaledVector4()
     {
         // arrange
-        var halfSingle = new HalfSingle(-1F);
+        HalfSingle pixel = new(-1F);
 
         // act
-        Vector4 actual = halfSingle.ToScaledVector4();
+        Vector4 actual = pixel.ToScaledVector4();
 
         // assert
         Assert.Equal(0, actual.X);
@@ -56,14 +57,28 @@ public class HalfSingleTests
     {
         // arrange
         Vector4 scaled = new HalfSingle(-1F).ToScaledVector4();
-        int expected = 48128;
-        var halfSingle = default(HalfSingle);
+        const int expected = 48128;
 
         // act
-        halfSingle.FromScaledVector4(scaled);
-        ushort actual = halfSingle.PackedValue;
+        HalfSingle pixel = HalfSingle.FromScaledVector4(scaled);
+        ushort actual = pixel.PackedValue;
 
         // assert
         Assert.Equal(expected, actual);
     }
+
+    [Fact]
+    public void HalfSingle_PixelInformation()
+    {
+        PixelTypeInfo info = HalfSingle.GetPixelTypeInfo();
+        Assert.Equal(Unsafe.SizeOf<HalfSingle>() * 8, info.BitsPerPixel);
+        Assert.Equal(PixelAlphaRepresentation.None, info.AlphaRepresentation);
+        Assert.Equal(PixelColorType.Red, info.ColorType);
+
+        PixelComponentInfo componentInfo = info.ComponentInfo.Value;
+        Assert.Equal(1, componentInfo.ComponentCount);
+        Assert.Equal(0, componentInfo.Padding);
+        Assert.Equal(16, componentInfo.GetComponentPrecision(0));
+        Assert.Equal(16, componentInfo.GetMaximumComponentPrecision());
+    }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/HalfVector2Tests.cs b/tests/ImageSharp.Tests/PixelFormats/HalfVector2Tests.cs
index eda931536..c5a89df1e 100644
--- a/tests/ImageSharp.Tests/PixelFormats/HalfVector2Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/HalfVector2Tests.cs
@@ -2,6 +2,7 @@
 // Licensed under the Six Labors Split License.
 
 using System.Numerics;
+using System.Runtime.CompilerServices;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Tests.PixelFormats;
@@ -30,7 +31,7 @@ public class HalfVector2Tests
     public void HalfVector2_ToScaledVector4()
     {
         // arrange
-        var halfVector = new HalfVector2(Vector2.One);
+        HalfVector2 halfVector = new(Vector2.One);
 
         // act
         Vector4 actual = halfVector.ToScaledVector4();
@@ -47,11 +48,10 @@ public class HalfVector2Tests
     {
         // arrange
         Vector4 scaled = new HalfVector2(Vector2.One).ToScaledVector4();
-        uint expected = 1006648320u;
-        var halfVector = default(HalfVector2);
+        const uint expected = 1006648320u;
 
         // act
-        halfVector.FromScaledVector4(scaled);
+        HalfVector2 halfVector = HalfVector2.FromScaledVector4(scaled);
         uint actual = halfVector.PackedValue;
 
         // assert
@@ -62,11 +62,11 @@ public class HalfVector2Tests
     public void HalfVector2_ToVector4()
     {
         // arrange
-        var halfVector = new HalfVector2(.5F, .25F);
-        var expected = new Vector4(0.5f, .25F, 0, 1);
+        HalfVector2 halfVector = new(.5F, .25F);
+        Vector4 expected = new(0.5f, .25F, 0, 1);
 
         // act
-        var actual = halfVector.ToVector4();
+        Vector4 actual = halfVector.ToVector4();
 
         // assert
         Assert.Equal(expected, actual);
@@ -75,17 +75,30 @@ public class HalfVector2Tests
     [Fact]
     public void HalfVector2_FromBgra5551()
     {
-        // arrange
-        var halfVector2 = default(HalfVector2);
-
         // act
-        halfVector2.FromBgra5551(new Bgra5551(1.0f, 1.0f, 1.0f, 1.0f));
+        HalfVector2 pixel = HalfVector2.FromBgra5551(new Bgra5551(1f, 1f, 1f, 1f));
 
         // assert
-        Vector4 actual = halfVector2.ToScaledVector4();
+        Vector4 actual = pixel.ToScaledVector4();
         Assert.Equal(1F, actual.X);
         Assert.Equal(1F, actual.Y);
         Assert.Equal(0, actual.Z);
         Assert.Equal(1, actual.W);
     }
+
+    [Fact]
+    public void HalfVector2_PixelInformation()
+    {
+        PixelTypeInfo info = HalfVector2.GetPixelTypeInfo();
+        Assert.Equal(Unsafe.SizeOf<HalfVector2>() * 8, info.BitsPerPixel);
+        Assert.Equal(PixelAlphaRepresentation.None, info.AlphaRepresentation);
+        Assert.Equal(PixelColorType.Red | PixelColorType.Green, info.ColorType);
+
+        PixelComponentInfo componentInfo = info.ComponentInfo.Value;
+        Assert.Equal(2, componentInfo.ComponentCount);
+        Assert.Equal(0, componentInfo.Padding);
+        Assert.Equal(16, componentInfo.GetComponentPrecision(0));
+        Assert.Equal(16, componentInfo.GetComponentPrecision(1));
+        Assert.Equal(16, componentInfo.GetMaximumComponentPrecision());
+    }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/HalfVector4Tests.cs b/tests/ImageSharp.Tests/PixelFormats/HalfVector4Tests.cs
index 77120192b..16c78a23d 100644
--- a/tests/ImageSharp.Tests/PixelFormats/HalfVector4Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/HalfVector4Tests.cs
@@ -2,6 +2,7 @@
 // Licensed under the Six Labors Split License.
 
 using System.Numerics;
+using System.Runtime.CompilerServices;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Tests.PixelFormats;
@@ -38,10 +39,10 @@ public class HalfVector4Tests
     public void HalfVector4_ToScaledVector4()
     {
         // arrange
-        var halfVector4 = new HalfVector4(-Vector4.One);
+        HalfVector4 pixel = new(-Vector4.One);
 
         // act
-        Vector4 actual = halfVector4.ToScaledVector4();
+        Vector4 actual = pixel.ToScaledVector4();
 
         // assert
         Assert.Equal(0, actual.X);
@@ -54,13 +55,12 @@ public class HalfVector4Tests
     public void HalfVector4_FromScaledVector4()
     {
         // arrange
-        var halfVector4 = default(HalfVector4);
         Vector4 scaled = new HalfVector4(-Vector4.One).ToScaledVector4();
-        ulong expected = 13547034390470638592uL;
+        const ulong expected = 13547034390470638592uL;
 
         // act
-        halfVector4.FromScaledVector4(scaled);
-        ulong actual = halfVector4.PackedValue;
+        HalfVector4 pixel = HalfVector4.FromScaledVector4(scaled);
+        ulong actual = pixel.PackedValue;
 
         // assert
         Assert.Equal(expected, actual);
@@ -70,13 +70,30 @@ public class HalfVector4Tests
     public void HalfVector4_FromBgra5551()
     {
         // arrange
-        var halfVector4 = default(HalfVector4);
         Vector4 expected = Vector4.One;
 
         // act
-        halfVector4.FromBgra5551(new Bgra5551(1.0f, 1.0f, 1.0f, 1.0f));
+        HalfVector4 pixel = HalfVector4.FromBgra5551(new Bgra5551(1.0f, 1.0f, 1.0f, 1.0f));
 
         // assert
-        Assert.Equal(expected, halfVector4.ToScaledVector4());
+        Assert.Equal(expected, pixel.ToScaledVector4());
+    }
+
+    [Fact]
+    public void HalfVector4_PixelInformation()
+    {
+        PixelTypeInfo info = HalfVector4.GetPixelTypeInfo();
+        Assert.Equal(Unsafe.SizeOf<HalfVector4>() * 8, info.BitsPerPixel);
+        Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
+        Assert.Equal(PixelColorType.RGB | PixelColorType.Alpha, info.ColorType);
+
+        PixelComponentInfo componentInfo = info.ComponentInfo.Value;
+        Assert.Equal(4, componentInfo.ComponentCount);
+        Assert.Equal(0, componentInfo.Padding);
+        Assert.Equal(16, componentInfo.GetComponentPrecision(0));
+        Assert.Equal(16, componentInfo.GetComponentPrecision(1));
+        Assert.Equal(16, componentInfo.GetComponentPrecision(2));
+        Assert.Equal(16, componentInfo.GetComponentPrecision(3));
+        Assert.Equal(16, componentInfo.GetMaximumComponentPrecision());
     }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/L16Tests.cs b/tests/ImageSharp.Tests/PixelFormats/L16Tests.cs
index 685da2ddf..2ddf1accb 100644
--- a/tests/ImageSharp.Tests/PixelFormats/L16Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/L16Tests.cs
@@ -2,6 +2,7 @@
 // Licensed under the Six Labors Split License.
 
 using System.Numerics;
+using System.Runtime.CompilerServices;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Tests.PixelFormats;
@@ -12,8 +13,8 @@ public class L16Tests
     [Fact]
     public void AreEqual()
     {
-        var color1 = new L16(3000);
-        var color2 = new L16(3000);
+        L16 color1 = new(3000);
+        L16 color2 = new(3000);
 
         Assert.Equal(color1, color2);
     }
@@ -21,8 +22,8 @@ public class L16Tests
     [Fact]
     public void AreNotEqual()
     {
-        var color1 = new L16(12345);
-        var color2 = new L16(54321);
+        L16 color1 = new(12345);
+        L16 color2 = new(54321);
 
         Assert.NotEqual(color1, color2);
     }
@@ -39,13 +40,12 @@ public class L16Tests
     public void L16_FromScaledVector4()
     {
         // Arrange
-        L16 gray = default;
         const ushort expected = 32767;
         Vector4 scaled = new L16(expected).ToScaledVector4();
 
         // Act
-        gray.FromScaledVector4(scaled);
-        ushort actual = gray.PackedValue;
+        L16 pixel = L16.FromScaledVector4(scaled);
+        ushort actual = pixel.PackedValue;
 
         // Assert
         Assert.Equal(expected, actual);
@@ -58,10 +58,10 @@ public class L16Tests
     public void L16_ToScaledVector4(ushort input)
     {
         // Arrange
-        var gray = new L16(input);
+        L16 pixel = new(input);
 
         // Act
-        Vector4 actual = gray.ToScaledVector4();
+        Vector4 actual = pixel.ToScaledVector4();
 
         // Assert
         float vectorInput = input / 65535F;
@@ -75,13 +75,12 @@ public class L16Tests
     public void L16_FromVector4()
     {
         // Arrange
-        L16 gray = default;
         const ushort expected = 32767;
-        var vector = new L16(expected).ToVector4();
+        Vector4 vector = new L16(expected).ToVector4();
 
         // Act
-        gray.FromVector4(vector);
-        ushort actual = gray.PackedValue;
+        L16 pixel = L16.FromVector4(vector);
+        ushort actual = pixel.PackedValue;
 
         // Assert
         Assert.Equal(expected, actual);
@@ -94,10 +93,10 @@ public class L16Tests
     public void L16_ToVector4(ushort input)
     {
         // Arrange
-        var gray = new L16(input);
+        L16 pixel = new(input);
 
         // Act
-        var actual = gray.ToVector4();
+        Vector4 actual = pixel.ToVector4();
 
         // Assert
         float vectorInput = input / 65535F;
@@ -111,14 +110,13 @@ public class L16Tests
     public void L16_FromRgba32()
     {
         // Arrange
-        L16 gray = default;
         const byte rgb = 128;
-        ushort scaledRgb = ColorNumerics.UpscaleFrom8BitTo16Bit(rgb);
+        ushort scaledRgb = ColorNumerics.From8BitTo16Bit(rgb);
         ushort expected = ColorNumerics.Get16BitBT709Luminance(scaledRgb, scaledRgb, scaledRgb);
 
         // Act
-        gray.FromRgba32(new Rgba32(rgb, rgb, rgb));
-        ushort actual = gray.PackedValue;
+        L16 pixel = L16.FromRgba32(new Rgba32(rgb, rgb, rgb));
+        ushort actual = pixel.PackedValue;
 
         // Assert
         Assert.Equal(expected, actual);
@@ -131,12 +129,11 @@ public class L16Tests
     public void L16_ToRgba32(ushort input)
     {
         // Arrange
-        ushort expected = ColorNumerics.DownScaleFrom16BitTo8Bit(input);
-        var gray = new L16(input);
+        ushort expected = ColorNumerics.From16BitTo8Bit(input);
+        L16 pixel = new(input);
 
         // Act
-        Rgba32 actual = default;
-        gray.ToRgba32(ref actual);
+        Rgba32 actual = pixel.ToRgba32();
 
         // Assert
         Assert.Equal(expected, actual.R);
@@ -149,13 +146,27 @@ public class L16Tests
     public void L16_FromBgra5551()
     {
         // arrange
-        var gray = default(L16);
-        ushort expected = ushort.MaxValue;
+        const ushort expected = ushort.MaxValue;
 
         // act
-        gray.FromBgra5551(new Bgra5551(1.0f, 1.0f, 1.0f, 1.0f));
+        L16 pixel = L16.FromBgra5551(new Bgra5551(1.0f, 1.0f, 1.0f, 1.0f));
 
         // assert
-        Assert.Equal(expected, gray.PackedValue);
+        Assert.Equal(expected, pixel.PackedValue);
+    }
+
+    [Fact]
+    public void L16_PixelInformation()
+    {
+        PixelTypeInfo info = L16.GetPixelTypeInfo();
+        Assert.Equal(Unsafe.SizeOf<L16>() * 8, info.BitsPerPixel);
+        Assert.Equal(PixelAlphaRepresentation.None, info.AlphaRepresentation);
+        Assert.Equal(PixelColorType.Grayscale, info.ColorType);
+
+        PixelComponentInfo componentInfo = info.ComponentInfo.Value;
+        Assert.Equal(1, componentInfo.ComponentCount);
+        Assert.Equal(0, componentInfo.Padding);
+        Assert.Equal(16, componentInfo.GetComponentPrecision(0));
+        Assert.Equal(16, componentInfo.GetMaximumComponentPrecision());
     }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/L8Tests.cs b/tests/ImageSharp.Tests/PixelFormats/L8Tests.cs
index afdc039a2..40c746cf2 100644
--- a/tests/ImageSharp.Tests/PixelFormats/L8Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/L8Tests.cs
@@ -2,6 +2,7 @@
 // Licensed under the Six Labors Split License.
 
 using System.Numerics;
+using System.Runtime.CompilerServices;
 using SixLabors.ImageSharp.PixelFormats;
 
 // ReSharper disable InconsistentNaming
@@ -24,8 +25,8 @@ public class L8Tests
     [Fact]
     public void AreEqual()
     {
-        var color1 = new L8(100);
-        var color2 = new L8(100);
+        L8 color1 = new(100);
+        L8 color2 = new(100);
 
         Assert.Equal(color1, color2);
     }
@@ -33,8 +34,8 @@ public class L8Tests
     [Fact]
     public void AreNotEqual()
     {
-        var color1 = new L8(100);
-        var color2 = new L8(200);
+        L8 color1 = new(100);
+        L8 color2 = new(200);
 
         Assert.NotEqual(color1, color2);
     }
@@ -43,13 +44,12 @@ public class L8Tests
     public void L8_FromScaledVector4()
     {
         // Arrange
-        L8 gray = default;
         const byte expected = 128;
         Vector4 scaled = new L8(expected).ToScaledVector4();
 
         // Act
-        gray.FromScaledVector4(scaled);
-        byte actual = gray.PackedValue;
+        L8 pixel = L8.FromScaledVector4(scaled);
+        byte actual = pixel.PackedValue;
 
         // Assert
         Assert.Equal(expected, actual);
@@ -60,10 +60,10 @@ public class L8Tests
     public void L8_ToScaledVector4(byte input)
     {
         // Arrange
-        var gray = new L8(input);
+        L8 pixel = new(input);
 
         // Act
-        Vector4 actual = gray.ToScaledVector4();
+        Vector4 actual = pixel.ToScaledVector4();
 
         // Assert
         float scaledInput = input / 255F;
@@ -78,12 +78,11 @@ public class L8Tests
     public void L8_FromVector4(byte luminance)
     {
         // Arrange
-        L8 gray = default;
-        var vector = new L8(luminance).ToVector4();
+        Vector4 vector = new L8(luminance).ToVector4();
 
         // Act
-        gray.FromVector4(vector);
-        byte actual = gray.PackedValue;
+        L8 pixel = L8.FromVector4(vector);
+        byte actual = pixel.PackedValue;
 
         // Assert
         Assert.Equal(luminance, actual);
@@ -94,10 +93,10 @@ public class L8Tests
     public void L8_ToVector4(byte input)
     {
         // Arrange
-        var gray = new L8(input);
+        L8 pixel = new(input);
 
         // Act
-        var actual = gray.ToVector4();
+        Vector4 actual = pixel.ToVector4();
 
         // Assert
         float scaledInput = input / 255F;
@@ -112,12 +111,11 @@ public class L8Tests
     public void L8_FromRgba32(byte rgb)
     {
         // Arrange
-        L8 gray = default;
         byte expected = ColorNumerics.Get8BitBT709Luminance(rgb, rgb, rgb);
 
         // Act
-        gray.FromRgba32(new Rgba32(rgb, rgb, rgb));
-        byte actual = gray.PackedValue;
+        L8 pixel = L8.FromRgba32(new Rgba32(rgb, rgb, rgb));
+        byte actual = pixel.PackedValue;
 
         // Assert
         Assert.Equal(expected, actual);
@@ -128,11 +126,10 @@ public class L8Tests
     public void L8_ToRgba32(byte luminance)
     {
         // Arrange
-        var gray = new L8(luminance);
+        L8 pixel = new(luminance);
 
         // Act
-        Rgba32 actual = default;
-        gray.ToRgba32(ref actual);
+        Rgba32 actual = pixel.ToRgba32();
 
         // Assert
         Assert.Equal(luminance, actual.R);
@@ -145,11 +142,10 @@ public class L8Tests
     public void L8_FromBgra5551()
     {
         // arrange
-        var grey = default(L8);
-        byte expected = byte.MaxValue;
+        const byte expected = byte.MaxValue;
 
         // act
-        grey.FromBgra5551(new Bgra5551(1.0f, 1.0f, 1.0f, 1.0f));
+        L8 grey = L8.FromBgra5551(new Bgra5551(1f, 1f, 1f, 1f));
 
         // assert
         Assert.Equal(expected, grey.PackedValue);
@@ -164,13 +160,11 @@ public class L8Tests
         [MemberData(nameof(LuminanceData))]
         public void L8_FromRgba32_IsInverseOf_ToRgba32(byte luminance)
         {
-            var original = new L8(luminance);
+            L8 original = new(luminance);
 
-            Rgba32 rgba = default;
-            original.ToRgba32(ref rgba);
+            Rgba32 rgba = original.ToRgba32();
 
-            L8 mirror = default;
-            mirror.FromRgba32(rgba);
+            L8 mirror = L8.FromRgba32(rgba);
 
             Assert.Equal(original, mirror);
         }
@@ -179,13 +173,10 @@ public class L8Tests
         [MemberData(nameof(LuminanceData))]
         public void Rgba32_ToL8_IsInverseOf_L8_ToRgba32(byte luminance)
         {
-            var original = new L8(luminance);
+            L8 original = new(luminance);
 
-            Rgba32 rgba = default;
-            original.ToRgba32(ref rgba);
-
-            L8 mirror = default;
-            mirror.FromRgba32(rgba);
+            Rgba32 rgba = original.ToRgba32();
+            L8 mirror = L8.FromRgba32(rgba);
 
             Assert.Equal(original, mirror);
         }
@@ -194,13 +185,12 @@ public class L8Tests
         [MemberData(nameof(LuminanceData))]
         public void ToVector4_IsRgba32Compatible(byte luminance)
         {
-            var original = new L8(luminance);
+            L8 original = new(luminance);
 
-            Rgba32 rgba = default;
-            original.ToRgba32(ref rgba);
+            Rgba32 rgba = original.ToRgba32();
 
-            var l8Vector = original.ToVector4();
-            var rgbaVector = original.ToVector4();
+            Vector4 l8Vector = original.ToVector4();
+            Vector4 rgbaVector = rgba.ToVector4();
 
             Assert.Equal(l8Vector, rgbaVector, new ApproximateFloatComparer(1e-5f));
         }
@@ -209,15 +199,13 @@ public class L8Tests
         [MemberData(nameof(LuminanceData))]
         public void FromVector4_IsRgba32Compatible(byte luminance)
         {
-            var original = new L8(luminance);
+            L8 original = new(luminance);
 
-            Rgba32 rgba = default;
-            original.ToRgba32(ref rgba);
+            Rgba32 rgba = original.ToRgba32();
 
-            var rgbaVector = original.ToVector4();
+            Vector4 rgbaVector = rgba.ToVector4();
 
-            L8 mirror = default;
-            mirror.FromVector4(rgbaVector);
+            L8 mirror = L8.FromVector4(rgbaVector);
 
             Assert.Equal(original, mirror);
         }
@@ -226,10 +214,9 @@ public class L8Tests
         [MemberData(nameof(LuminanceData))]
         public void ToScaledVector4_IsRgba32Compatible(byte luminance)
         {
-            var original = new L8(luminance);
+            L8 original = new(luminance);
 
-            Rgba32 rgba = default;
-            original.ToRgba32(ref rgba);
+            Rgba32 rgba = original.ToRgba32();
 
             Vector4 l8Vector = original.ToScaledVector4();
             Vector4 rgbaVector = original.ToScaledVector4();
@@ -241,17 +228,30 @@ public class L8Tests
         [MemberData(nameof(LuminanceData))]
         public void FromScaledVector4_IsRgba32Compatible(byte luminance)
         {
-            var original = new L8(luminance);
+            L8 original = new(luminance);
 
-            Rgba32 rgba = default;
-            original.ToRgba32(ref rgba);
+            Rgba32 rgba = original.ToRgba32();
 
-            Vector4 rgbaVector = original.ToScaledVector4();
+            Vector4 rgbaVector = rgba.ToScaledVector4();
 
-            L8 mirror = default;
-            mirror.FromScaledVector4(rgbaVector);
+            L8 mirror = L8.FromScaledVector4(rgbaVector);
 
             Assert.Equal(original, mirror);
         }
+
+        [Fact]
+        public void L8_PixelInformation()
+        {
+            PixelTypeInfo info = L8.GetPixelTypeInfo();
+            Assert.Equal(Unsafe.SizeOf<L8>() * 8, info.BitsPerPixel);
+            Assert.Equal(PixelAlphaRepresentation.None, info.AlphaRepresentation);
+            Assert.Equal(PixelColorType.Grayscale, info.ColorType);
+
+            PixelComponentInfo componentInfo = info.ComponentInfo.Value;
+            Assert.Equal(1, componentInfo.ComponentCount);
+            Assert.Equal(0, componentInfo.Padding);
+            Assert.Equal(8, componentInfo.GetComponentPrecision(0));
+            Assert.Equal(8, componentInfo.GetMaximumComponentPrecision());
+        }
     }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/La16Tests.cs b/tests/ImageSharp.Tests/PixelFormats/La16Tests.cs
index 92b4a4e1a..a18b31f6b 100644
--- a/tests/ImageSharp.Tests/PixelFormats/La16Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/La16Tests.cs
@@ -2,6 +2,7 @@
 // Licensed under the Six Labors Split License.
 
 using System.Numerics;
+using System.Runtime.CompilerServices;
 using SixLabors.ImageSharp.PixelFormats;
 
 // ReSharper disable InconsistentNaming
@@ -24,8 +25,8 @@ public class La16Tests
     [Fact]
     public void AreEqual()
     {
-        var color1 = new La16(100, 50);
-        var color2 = new La16(100, 50);
+        La16 color1 = new(100, 50);
+        La16 color2 = new(100, 50);
 
         Assert.Equal(color1, color2);
     }
@@ -33,8 +34,8 @@ public class La16Tests
     [Fact]
     public void AreNotEqual()
     {
-        var color1 = new La16(100, 50);
-        var color2 = new La16(200, 50);
+        La16 color1 = new(100, 50);
+        La16 color2 = new(200, 50);
 
         Assert.NotEqual(color1, color2);
     }
@@ -43,12 +44,11 @@ public class La16Tests
     public void La16_FromScaledVector4()
     {
         // Arrange
-        La16 gray = default;
         const ushort expected = 32896;
         Vector4 scaled = new La16(128, 128).ToScaledVector4();
 
         // Act
-        gray.FromScaledVector4(scaled);
+        La16 gray = La16.FromScaledVector4(scaled);
         ushort actual = gray.PackedValue;
 
         // Assert
@@ -60,7 +60,7 @@ public class La16Tests
     public void La16_ToScaledVector4(byte input)
     {
         // Arrange
-        var gray = new La16(input, input);
+        La16 gray = new(input, input);
 
         // Act
         Vector4 actual = gray.ToScaledVector4();
@@ -78,11 +78,10 @@ public class La16Tests
     public void La16_FromVector4(byte luminance)
     {
         // Arrange
-        La16 gray = default;
-        var vector = new La16(luminance, luminance).ToVector4();
+        Vector4 vector = new La16(luminance, luminance).ToVector4();
 
         // Act
-        gray.FromVector4(vector);
+        La16 gray = La16.FromVector4(vector);
         byte actualL = gray.L;
         byte actualA = gray.A;
 
@@ -96,10 +95,10 @@ public class La16Tests
     public void La16_ToVector4(byte input)
     {
         // Arrange
-        var gray = new La16(input, input);
+        La16 gray = new(input, input);
 
         // Act
-        var actual = gray.ToVector4();
+        Vector4 actual = gray.ToVector4();
 
         // Assert
         float scaledInput = input / 255F;
@@ -114,11 +113,10 @@ public class La16Tests
     public void La16_FromRgba32(byte rgb)
     {
         // Arrange
-        La16 gray = default;
         byte expected = ColorNumerics.Get8BitBT709Luminance(rgb, rgb, rgb);
 
         // Act
-        gray.FromRgba32(new Rgba32(rgb, rgb, rgb));
+        La16 gray = La16.FromRgba32(new Rgba32(rgb, rgb, rgb));
         byte actual = gray.L;
 
         // Assert
@@ -131,11 +129,10 @@ public class La16Tests
     public void La16_ToRgba32(byte luminance)
     {
         // Arrange
-        var gray = new La16(luminance, luminance);
+        La16 gray = new(luminance, luminance);
 
         // Act
-        Rgba32 actual = default;
-        gray.ToRgba32(ref actual);
+        Rgba32 actual = gray.ToRgba32();
 
         // Assert
         Assert.Equal(luminance, actual.R);
@@ -148,11 +145,10 @@ public class La16Tests
     public void La16_FromBgra5551()
     {
         // arrange
-        var grey = default(La16);
-        byte expected = byte.MaxValue;
+        const byte expected = byte.MaxValue;
 
         // act
-        grey.FromBgra5551(new Bgra5551(1.0f, 1.0f, 1.0f, 1.0f));
+        La16 grey = La16.FromBgra5551(new Bgra5551(1.0f, 1.0f, 1.0f, 1.0f));
 
         // assert
         Assert.Equal(expected, grey.L);
@@ -168,13 +164,11 @@ public class La16Tests
         [MemberData(nameof(LuminanceData))]
         public void La16_FromRgba32_IsInverseOf_ToRgba32(byte luminance)
         {
-            var original = new La16(luminance, luminance);
+            La16 original = new(luminance, luminance);
 
-            Rgba32 rgba = default;
-            original.ToRgba32(ref rgba);
+            Rgba32 rgba = original.ToRgba32();
 
-            La16 mirror = default;
-            mirror.FromRgba32(rgba);
+            La16 mirror = La16.FromRgba32(rgba);
 
             Assert.Equal(original, mirror);
         }
@@ -183,13 +177,11 @@ public class La16Tests
         [MemberData(nameof(LuminanceData))]
         public void Rgba32_ToLa16_IsInverseOf_La16_ToRgba32(byte luminance)
         {
-            var original = new La16(luminance, luminance);
+            La16 original = new(luminance, luminance);
 
-            Rgba32 rgba = default;
-            original.ToRgba32(ref rgba);
+            Rgba32 rgba = original.ToRgba32();
 
-            La16 mirror = default;
-            mirror.FromRgba32(rgba);
+            La16 mirror = La16.FromRgba32(rgba);
 
             Assert.Equal(original, mirror);
         }
@@ -198,13 +190,12 @@ public class La16Tests
         [MemberData(nameof(LuminanceData))]
         public void ToVector4_IsRgba32Compatible(byte luminance)
         {
-            var original = new La16(luminance, luminance);
+            La16 original = new(luminance, luminance);
 
-            Rgba32 rgba = default;
-            original.ToRgba32(ref rgba);
+            Rgba32 rgba = original.ToRgba32();
 
-            var la16Vector = original.ToVector4();
-            var rgbaVector = original.ToVector4();
+            Vector4 la16Vector = original.ToVector4();
+            Vector4 rgbaVector = rgba.ToVector4();
 
             Assert.Equal(la16Vector, rgbaVector, new ApproximateFloatComparer(1e-5f));
         }
@@ -213,15 +204,12 @@ public class La16Tests
         [MemberData(nameof(LuminanceData))]
         public void FromVector4_IsRgba32Compatible(byte luminance)
         {
-            var original = new La16(luminance, luminance);
+            La16 original = new(luminance, luminance);
 
-            Rgba32 rgba = default;
-            original.ToRgba32(ref rgba);
+            Rgba32 rgba = original.ToRgba32();
+            Vector4 rgbaVector = rgba.ToVector4();
 
-            var rgbaVector = original.ToVector4();
-
-            La16 mirror = default;
-            mirror.FromVector4(rgbaVector);
+            La16 mirror = La16.FromVector4(rgbaVector);
 
             Assert.Equal(original, mirror);
         }
@@ -230,13 +218,12 @@ public class La16Tests
         [MemberData(nameof(LuminanceData))]
         public void ToScaledVector4_IsRgba32Compatible(byte luminance)
         {
-            var original = new La16(luminance, luminance);
+            La16 original = new(luminance, luminance);
 
-            Rgba32 rgba = default;
-            original.ToRgba32(ref rgba);
+            Rgba32 rgba = original.ToRgba32();
 
             Vector4 la16Vector = original.ToScaledVector4();
-            Vector4 rgbaVector = original.ToScaledVector4();
+            Vector4 rgbaVector = rgba.ToScaledVector4();
 
             Assert.Equal(la16Vector, rgbaVector, new ApproximateFloatComparer(1e-5f));
         }
@@ -245,17 +232,30 @@ public class La16Tests
         [MemberData(nameof(LuminanceData))]
         public void FromScaledVector4_IsRgba32Compatible(byte luminance)
         {
-            var original = new La16(luminance, luminance);
-
-            Rgba32 rgba = default;
-            original.ToRgba32(ref rgba);
+            La16 original = new(luminance, luminance);
 
-            Vector4 rgbaVector = original.ToScaledVector4();
+            Rgba32 rgba = original.ToRgba32();
+            Vector4 rgbaVector = rgba.ToScaledVector4();
 
-            La16 mirror = default;
-            mirror.FromScaledVector4(rgbaVector);
+            La16 mirror = La16.FromScaledVector4(rgbaVector);
 
             Assert.Equal(original, mirror);
         }
+
+        [Fact]
+        public void La16_PixelInformation()
+        {
+            PixelTypeInfo info = La16.GetPixelTypeInfo();
+            Assert.Equal(Unsafe.SizeOf<La16>() * 8, info.BitsPerPixel);
+            Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
+            Assert.Equal(PixelColorType.Grayscale | PixelColorType.Alpha, info.ColorType);
+
+            PixelComponentInfo componentInfo = info.ComponentInfo.Value;
+            Assert.Equal(2, componentInfo.ComponentCount);
+            Assert.Equal(0, componentInfo.Padding);
+            Assert.Equal(8, componentInfo.GetComponentPrecision(0));
+            Assert.Equal(8, componentInfo.GetComponentPrecision(1));
+            Assert.Equal(8, componentInfo.GetMaximumComponentPrecision());
+        }
     }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/La32Tests.cs b/tests/ImageSharp.Tests/PixelFormats/La32Tests.cs
index d333818c7..3c702419d 100644
--- a/tests/ImageSharp.Tests/PixelFormats/La32Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/La32Tests.cs
@@ -2,6 +2,7 @@
 // Licensed under the Six Labors Split License.
 
 using System.Numerics;
+using System.Runtime.CompilerServices;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Tests.PixelFormats;
@@ -12,8 +13,8 @@ public class La32Tests
     [Fact]
     public void AreEqual()
     {
-        var color1 = new La32(3000, 100);
-        var color2 = new La32(3000, 100);
+        La32 color1 = new(3000, 100);
+        La32 color2 = new(3000, 100);
 
         Assert.Equal(color1, color2);
     }
@@ -21,8 +22,8 @@ public class La32Tests
     [Fact]
     public void AreNotEqual()
     {
-        var color1 = new La32(12345, 100);
-        var color2 = new La32(54321, 100);
+        La32 color1 = new(12345, 100);
+        La32 color2 = new(54321, 100);
 
         Assert.NotEqual(color1, color2);
     }
@@ -39,14 +40,13 @@ public class La32Tests
     public void La32_FromScaledVector4()
     {
         // Arrange
-        La32 gray = default;
         const ushort expected = 32767;
         Vector4 scaled = new La32(expected, expected).ToScaledVector4();
 
         // Act
-        gray.FromScaledVector4(scaled);
-        ushort actual = gray.L;
-        ushort actualA = gray.A;
+        La32 pixel = La32.FromScaledVector4(scaled);
+        ushort actual = pixel.L;
+        ushort actualA = pixel.A;
 
         // Assert
         Assert.Equal(expected, actual);
@@ -60,10 +60,10 @@ public class La32Tests
     public void La32_ToScaledVector4(ushort input)
     {
         // Arrange
-        var gray = new La32(input, input);
+        La32 pixel = new(input, input);
 
         // Act
-        Vector4 actual = gray.ToScaledVector4();
+        Vector4 actual = pixel.ToScaledVector4();
 
         // Assert
         float vectorInput = input / 65535F;
@@ -77,14 +77,13 @@ public class La32Tests
     public void La32_FromVector4()
     {
         // Arrange
-        La32 gray = default;
         const ushort expected = 32767;
-        var vector = new La32(expected, expected).ToVector4();
+        Vector4 vector = new La32(expected, expected).ToVector4();
 
         // Act
-        gray.FromVector4(vector);
-        ushort actual = gray.L;
-        ushort actualA = gray.A;
+        La32 pixel = La32.FromVector4(vector);
+        ushort actual = pixel.L;
+        ushort actualA = pixel.A;
 
         // Assert
         Assert.Equal(expected, actual);
@@ -98,10 +97,10 @@ public class La32Tests
     public void La32_ToVector4(ushort input)
     {
         // Arrange
-        var gray = new La32(input, input);
+        La32 pixel = new(input, input);
 
         // Act
-        var actual = gray.ToVector4();
+        Vector4 actual = pixel.ToVector4();
 
         // Assert
         float vectorInput = input / 65535F;
@@ -115,18 +114,17 @@ public class La32Tests
     public void La32_FromRgba32()
     {
         // Arrange
-        La32 gray = default;
         const byte rgb = 128;
-        ushort scaledRgb = ColorNumerics.UpscaleFrom8BitTo16Bit(rgb);
+        ushort scaledRgb = ColorNumerics.From8BitTo16Bit(rgb);
         ushort expected = ColorNumerics.Get16BitBT709Luminance(scaledRgb, scaledRgb, scaledRgb);
 
         // Act
-        gray.FromRgba32(new Rgba32(rgb, rgb, rgb));
-        ushort actual = gray.L;
+        La32 pixel = La32.FromRgba32(new Rgba32(rgb, rgb, rgb));
+        ushort actual = pixel.L;
 
         // Assert
         Assert.Equal(expected, actual);
-        Assert.Equal(ushort.MaxValue, gray.A);
+        Assert.Equal(ushort.MaxValue, pixel.A);
     }
 
     [Theory]
@@ -136,12 +134,11 @@ public class La32Tests
     public void La32_ToRgba32(ushort input)
     {
         // Arrange
-        ushort expected = ColorNumerics.DownScaleFrom16BitTo8Bit(input);
-        var gray = new La32(input, ushort.MaxValue);
+        ushort expected = ColorNumerics.From16BitTo8Bit(input);
+        La32 pixel = new(input, ushort.MaxValue);
 
         // Act
-        Rgba32 actual = default;
-        gray.ToRgba32(ref actual);
+        Rgba32 actual = pixel.ToRgba32();
 
         // Assert
         Assert.Equal(expected, actual.R);
@@ -154,14 +151,29 @@ public class La32Tests
     public void La32_FromBgra5551()
     {
         // arrange
-        var gray = default(La32);
-        ushort expected = ushort.MaxValue;
+        const ushort expected = ushort.MaxValue;
 
         // act
-        gray.FromBgra5551(new Bgra5551(1.0f, 1.0f, 1.0f, 1.0f));
+        La32 pixel = La32.FromBgra5551(new Bgra5551(1f, 1f, 1f, 1f));
 
         // assert
-        Assert.Equal(expected, gray.L);
-        Assert.Equal(expected, gray.A);
+        Assert.Equal(expected, pixel.L);
+        Assert.Equal(expected, pixel.A);
+    }
+
+    [Fact]
+    public void La32_PixelInformation()
+    {
+        PixelTypeInfo info = La32.GetPixelTypeInfo();
+        Assert.Equal(Unsafe.SizeOf<La32>() * 8, info.BitsPerPixel);
+        Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
+        Assert.Equal(PixelColorType.Grayscale | PixelColorType.Alpha, info.ColorType);
+
+        PixelComponentInfo componentInfo = info.ComponentInfo.Value;
+        Assert.Equal(2, componentInfo.ComponentCount);
+        Assert.Equal(0, componentInfo.Padding);
+        Assert.Equal(16, componentInfo.GetComponentPrecision(0));
+        Assert.Equal(16, componentInfo.GetComponentPrecision(1));
+        Assert.Equal(16, componentInfo.GetMaximumComponentPrecision());
     }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/NormalizedByte2Tests.cs b/tests/ImageSharp.Tests/PixelFormats/NormalizedByte2Tests.cs
index 14c590d0b..ffbddb139 100644
--- a/tests/ImageSharp.Tests/PixelFormats/NormalizedByte2Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/NormalizedByte2Tests.cs
@@ -2,6 +2,7 @@
 // Licensed under the Six Labors Split License.
 
 using System.Numerics;
+using System.Runtime.CompilerServices;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Tests.PixelFormats;
@@ -39,10 +40,10 @@ public class NormalizedByte2Tests
     public void NormalizedByte2_ToScaledVector4()
     {
         // arrange
-        var byte2 = new NormalizedByte2(-Vector2.One);
+        NormalizedByte2 pixel = new(-Vector2.One);
 
         // act
-        Vector4 actual = byte2.ToScaledVector4();
+        Vector4 actual = pixel.ToScaledVector4();
 
         // assert
         Assert.Equal(0, actual.X);
@@ -56,12 +57,11 @@ public class NormalizedByte2Tests
     {
         // arrange
         Vector4 scaled = new NormalizedByte2(-Vector2.One).ToScaledVector4();
-        var byte2 = default(NormalizedByte2);
-        uint expected = 0x8181;
+        const uint expected = 0x8181;
 
         // act
-        byte2.FromScaledVector4(scaled);
-        uint actual = byte2.PackedValue;
+        NormalizedByte2 pixel = NormalizedByte2.FromScaledVector4(scaled);
+        uint actual = pixel.PackedValue;
 
         // assert
         Assert.Equal(expected, actual);
@@ -71,13 +71,28 @@ public class NormalizedByte2Tests
     public void NormalizedByte2_FromBgra5551()
     {
         // arrange
-        var normalizedByte2 = default(NormalizedByte2);
-        var expected = new Vector4(1, 1, 0, 1);
+        Vector4 expected = new(1, 1, 0, 1);
 
         // act
-        normalizedByte2.FromBgra5551(new Bgra5551(1.0f, 1.0f, 1.0f, 1.0f));
+        NormalizedByte2 pixel = NormalizedByte2.FromBgra5551(new Bgra5551(1f, 1f, 1f, 1f));
 
         // assert
-        Assert.Equal(expected, normalizedByte2.ToVector4());
+        Assert.Equal(expected, pixel.ToVector4());
+    }
+
+    [Fact]
+    public void NormalizedByte2_PixelInformation()
+    {
+        PixelTypeInfo info = NormalizedByte2.GetPixelTypeInfo();
+        Assert.Equal(Unsafe.SizeOf<NormalizedByte2>() * 8, info.BitsPerPixel);
+        Assert.Equal(PixelAlphaRepresentation.None, info.AlphaRepresentation);
+        Assert.Equal(PixelColorType.Red | PixelColorType.Green, info.ColorType);
+
+        PixelComponentInfo componentInfo = info.ComponentInfo.Value;
+        Assert.Equal(2, componentInfo.ComponentCount);
+        Assert.Equal(0, componentInfo.Padding);
+        Assert.Equal(8, componentInfo.GetComponentPrecision(0));
+        Assert.Equal(8, componentInfo.GetComponentPrecision(1));
+        Assert.Equal(8, componentInfo.GetMaximumComponentPrecision());
     }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/NormalizedByte4Tests.cs b/tests/ImageSharp.Tests/PixelFormats/NormalizedByte4Tests.cs
index ca73a6c1f..5a025f6c4 100644
--- a/tests/ImageSharp.Tests/PixelFormats/NormalizedByte4Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/NormalizedByte4Tests.cs
@@ -2,6 +2,7 @@
 // Licensed under the Six Labors Split License.
 
 using System.Numerics;
+using System.Runtime.CompilerServices;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Tests.PixelFormats;
@@ -15,10 +16,10 @@ public class NormalizedByte4Tests
     [Fact]
     public void AreEqual()
     {
-        var color1 = new NormalizedByte4(0.0f, 0.0f, 0.0f, 0.0f);
-        var color2 = new NormalizedByte4(new Vector4(0.0f));
-        var color3 = new NormalizedByte4(new Vector4(1.0f, 0.0f, 1.0f, 1.0f));
-        var color4 = new NormalizedByte4(1.0f, 0.0f, 1.0f, 1.0f);
+        NormalizedByte4 color1 = new(0.0f, 0.0f, 0.0f, 0.0f);
+        NormalizedByte4 color2 = new(new Vector4(0.0f));
+        NormalizedByte4 color3 = new(new Vector4(1f, 0.0f, 1f, 1f));
+        NormalizedByte4 color4 = new(1f, 0.0f, 1f, 1f);
 
         Assert.Equal(color1, color2);
         Assert.Equal(color3, color4);
@@ -30,10 +31,10 @@ public class NormalizedByte4Tests
     [Fact]
     public void AreNotEqual()
     {
-        var color1 = new NormalizedByte4(0.0f, 0.0f, 0.0f, 0.0f);
-        var color2 = new NormalizedByte4(new Vector4(1.0f));
-        var color3 = new NormalizedByte4(new Vector4(1.0f, 0.0f, 0.0f, 1.0f));
-        var color4 = new NormalizedByte4(1.0f, 1.0f, 0.0f, 1.0f);
+        NormalizedByte4 color1 = new(0.0f, 0.0f, 0.0f, 0.0f);
+        NormalizedByte4 color2 = new(new Vector4(1f));
+        NormalizedByte4 color3 = new(new Vector4(1f, 0.0f, 0.0f, 1f));
+        NormalizedByte4 color4 = new(1f, 1f, 0.0f, 1f);
 
         Assert.NotEqual(color1, color2);
         Assert.NotEqual(color3, color4);
@@ -63,7 +64,7 @@ public class NormalizedByte4Tests
     public void NormalizedByte4_ToScaledVector4()
     {
         // arrange
-        var short4 = new NormalizedByte4(-Vector4.One);
+        NormalizedByte4 short4 = new(-Vector4.One);
 
         // act
         Vector4 actual = short4.ToScaledVector4();
@@ -79,12 +80,11 @@ public class NormalizedByte4Tests
     public void NormalizedByte4_FromScaledVector4()
     {
         // arrange
-        var pixel = default(NormalizedByte4);
         Vector4 scaled = new NormalizedByte4(-Vector4.One).ToScaledVector4();
-        uint expected = 0x81818181;
+        const uint expected = 0x81818181;
 
         // act
-        pixel.FromScaledVector4(scaled);
+        NormalizedByte4 pixel = NormalizedByte4.FromScaledVector4(scaled);
         uint actual = pixel.PackedValue;
 
         // assert
@@ -95,139 +95,147 @@ public class NormalizedByte4Tests
     public void NormalizedByte4_FromArgb32()
     {
         // arrange
-        var byte4 = default(NormalizedByte4);
         Vector4 expected = Vector4.One;
 
         // act
-        byte4.FromArgb32(new Argb32(255, 255, 255, 255));
+        NormalizedByte4 pixel = NormalizedByte4.FromArgb32(new Argb32(255, 255, 255, 255));
 
         // assert
-        Assert.Equal(expected, byte4.ToScaledVector4());
+        Assert.Equal(expected, pixel.ToScaledVector4());
     }
 
     [Fact]
     public void NormalizedByte4_FromBgr24()
     {
         // arrange
-        var byte4 = default(NormalizedByte4);
         Vector4 expected = Vector4.One;
 
         // act
-        byte4.FromBgr24(new Bgr24(byte.MaxValue, byte.MaxValue, byte.MaxValue));
+        NormalizedByte4 pixel = NormalizedByte4.FromBgr24(new Bgr24(byte.MaxValue, byte.MaxValue, byte.MaxValue));
 
         // assert
-        Assert.Equal(expected, byte4.ToScaledVector4());
+        Assert.Equal(expected, pixel.ToScaledVector4());
     }
 
     [Fact]
     public void NormalizedByte4_FromGrey8()
     {
         // arrange
-        var byte4 = default(NormalizedByte4);
         Vector4 expected = Vector4.One;
 
         // act
-        byte4.FromL8(new L8(byte.MaxValue));
+        NormalizedByte4 pixel = NormalizedByte4.FromL8(new L8(byte.MaxValue));
 
         // assert
-        Assert.Equal(expected, byte4.ToScaledVector4());
+        Assert.Equal(expected, pixel.ToScaledVector4());
     }
 
     [Fact]
     public void NormalizedByte4_FromGrey16()
     {
         // arrange
-        var byte4 = default(NormalizedByte4);
         Vector4 expected = Vector4.One;
 
         // act
-        byte4.FromL16(new L16(ushort.MaxValue));
+        NormalizedByte4 pixel = NormalizedByte4.FromL16(new L16(ushort.MaxValue));
 
         // assert
-        Assert.Equal(expected, byte4.ToScaledVector4());
+        Assert.Equal(expected, pixel.ToScaledVector4());
     }
 
     [Fact]
     public void NormalizedByte4_FromRgb24()
     {
         // arrange
-        var byte4 = default(NormalizedByte4);
         Vector4 expected = Vector4.One;
 
         // act
-        byte4.FromRgb24(new Rgb24(byte.MaxValue, byte.MaxValue, byte.MaxValue));
+        NormalizedByte4 pixel = NormalizedByte4.FromRgb24(new Rgb24(byte.MaxValue, byte.MaxValue, byte.MaxValue));
 
         // assert
-        Assert.Equal(expected, byte4.ToScaledVector4());
+        Assert.Equal(expected, pixel.ToScaledVector4());
     }
 
     [Fact]
     public void NormalizedByte4_FromRgba32()
     {
         // arrange
-        var byte4 = default(NormalizedByte4);
         Vector4 expected = Vector4.One;
 
         // act
-        byte4.FromRgba32(new Rgba32(255, 255, 255, 255));
+        NormalizedByte4 pixel = NormalizedByte4.FromRgba32(new Rgba32(255, 255, 255, 255));
 
         // assert
-        Assert.Equal(expected, byte4.ToScaledVector4());
+        Assert.Equal(expected, pixel.ToScaledVector4());
     }
 
     [Fact]
     public void NormalizedByte4_FromBgra5551()
     {
         // arrange
-        var normalizedByte4 = default(NormalizedByte4);
         Vector4 expected = Vector4.One;
 
         // act
-        normalizedByte4.FromBgra5551(new Bgra5551(1.0f, 1.0f, 1.0f, 1.0f));
+        NormalizedByte4 pixel = NormalizedByte4.FromBgra5551(new Bgra5551(1f, 1f, 1f, 1f));
 
         // assert
-        Assert.Equal(expected, normalizedByte4.ToVector4());
+        Assert.Equal(expected, pixel.ToVector4());
     }
 
     [Fact]
     public void NormalizedByte4_FromRgb48()
     {
         // arrange
-        var byte4 = default(NormalizedByte4);
         Vector4 expected = Vector4.One;
 
         // act
-        byte4.FromRgb48(new Rgb48(ushort.MaxValue, ushort.MaxValue, ushort.MaxValue));
+        NormalizedByte4 pixel = NormalizedByte4.FromRgb48(new Rgb48(ushort.MaxValue, ushort.MaxValue, ushort.MaxValue));
 
         // assert
-        Assert.Equal(expected, byte4.ToScaledVector4());
+        Assert.Equal(expected, pixel.ToScaledVector4());
     }
 
     [Fact]
     public void NormalizedByte4_FromRgba64()
     {
         // arrange
-        var byte4 = default(NormalizedByte4);
         Vector4 expected = Vector4.One;
 
         // act
-        byte4.FromRgba64(new Rgba64(ushort.MaxValue, ushort.MaxValue, ushort.MaxValue, ushort.MaxValue));
+        NormalizedByte4 pixel = NormalizedByte4.FromRgba64(new Rgba64(ushort.MaxValue, ushort.MaxValue, ushort.MaxValue, ushort.MaxValue));
 
         // assert
-        Assert.Equal(expected, byte4.ToScaledVector4());
+        Assert.Equal(expected, pixel.ToScaledVector4());
     }
 
     [Fact]
     public void NormalizedByte4_ToRgba32()
     {
         // arrange
-        var byte4 = new NormalizedByte4(byte.MaxValue, byte.MaxValue, byte.MaxValue, byte.MaxValue);
-        var expected = new Rgba32(Vector4.One);
-        var actual = default(Rgba32);
+        NormalizedByte4 pixel = new(byte.MaxValue, byte.MaxValue, byte.MaxValue, byte.MaxValue);
+        Rgba32 expected = new(Vector4.One);
 
         // act
-        byte4.ToRgba32(ref actual);
+        Rgba32 actual = pixel.ToRgba32();
 
         Assert.Equal(expected, actual);
     }
+
+    [Fact]
+    public void NormalizedByte4_PixelInformation()
+    {
+        PixelTypeInfo info = NormalizedByte4.GetPixelTypeInfo();
+        Assert.Equal(Unsafe.SizeOf<NormalizedByte4>() * 8, info.BitsPerPixel);
+        Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
+        Assert.Equal(PixelColorType.RGB | PixelColorType.Alpha, info.ColorType);
+
+        PixelComponentInfo componentInfo = info.ComponentInfo.Value;
+        Assert.Equal(4, componentInfo.ComponentCount);
+        Assert.Equal(0, componentInfo.Padding);
+        Assert.Equal(8, componentInfo.GetComponentPrecision(0));
+        Assert.Equal(8, componentInfo.GetComponentPrecision(1));
+        Assert.Equal(8, componentInfo.GetComponentPrecision(2));
+        Assert.Equal(8, componentInfo.GetComponentPrecision(3));
+        Assert.Equal(8, componentInfo.GetMaximumComponentPrecision());
+    }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/NormalizedShort2Tests.cs b/tests/ImageSharp.Tests/PixelFormats/NormalizedShort2Tests.cs
index 70bfa1be7..be7b39052 100644
--- a/tests/ImageSharp.Tests/PixelFormats/NormalizedShort2Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/NormalizedShort2Tests.cs
@@ -2,6 +2,7 @@
 // Licensed under the Six Labors Split License.
 
 using System.Numerics;
+using System.Runtime.CompilerServices;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Tests.PixelFormats;
@@ -43,7 +44,7 @@ public class NormalizedShort2Tests
     public void NormalizedShort2_ToScaledVector4()
     {
         // arrange
-        var short2 = new NormalizedShort2(-Vector2.One);
+        NormalizedShort2 short2 = new(-Vector2.One);
 
         // act
         Vector4 actual = short2.ToScaledVector4();
@@ -60,11 +61,10 @@ public class NormalizedShort2Tests
     {
         // arrange
         Vector4 scaled = new NormalizedShort2(-Vector2.One).ToScaledVector4();
-        var short2 = default(NormalizedShort2);
-        uint expected = 0x80018001;
+        const uint expected = 0x80018001;
 
         // act
-        short2.FromScaledVector4(scaled);
+        NormalizedShort2 short2 = NormalizedShort2.FromScaledVector4(scaled);
         uint actual = short2.PackedValue;
 
         // assert
@@ -75,13 +75,28 @@ public class NormalizedShort2Tests
     public void NormalizedShort2_FromBgra5551()
     {
         // arrange
-        var normalizedShort2 = default(NormalizedShort2);
-        var expected = new Vector4(1, 1, 0, 1);
+        Vector4 expected = new(1, 1, 0, 1);
 
         // act
-        normalizedShort2.FromBgra5551(new Bgra5551(1.0f, 1.0f, 1.0f, 1.0f));
+        NormalizedShort2 normalizedShort2 = NormalizedShort2.FromBgra5551(new Bgra5551(1f, 1f, 1f, 1f));
 
         // assert
         Assert.Equal(expected, normalizedShort2.ToVector4());
     }
+
+    [Fact]
+    public void NormalizedShort2_PixelInformation()
+    {
+        PixelTypeInfo info = NormalizedShort2.GetPixelTypeInfo();
+        Assert.Equal(Unsafe.SizeOf<NormalizedShort2>() * 8, info.BitsPerPixel);
+        Assert.Equal(PixelAlphaRepresentation.None, info.AlphaRepresentation);
+        Assert.Equal(PixelColorType.Red | PixelColorType.Green, info.ColorType);
+
+        PixelComponentInfo componentInfo = info.ComponentInfo.Value;
+        Assert.Equal(2, componentInfo.ComponentCount);
+        Assert.Equal(0, componentInfo.Padding);
+        Assert.Equal(16, componentInfo.GetComponentPrecision(0));
+        Assert.Equal(16, componentInfo.GetComponentPrecision(1));
+        Assert.Equal(16, componentInfo.GetMaximumComponentPrecision());
+    }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/NormalizedShort4Tests.cs b/tests/ImageSharp.Tests/PixelFormats/NormalizedShort4Tests.cs
index 997c6df82..281ae7ee5 100644
--- a/tests/ImageSharp.Tests/PixelFormats/NormalizedShort4Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/NormalizedShort4Tests.cs
@@ -2,6 +2,7 @@
 // Licensed under the Six Labors Split License.
 
 using System.Numerics;
+using System.Runtime.CompilerServices;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Tests.PixelFormats;
@@ -15,10 +16,10 @@ public class NormalizedShort4Tests
     [Fact]
     public void AreEqual()
     {
-        var color1 = new NormalizedShort4(0.0f, 0.0f, 0.0f, 0.0f);
-        var color2 = new NormalizedShort4(new Vector4(0.0f));
-        var color3 = new NormalizedShort4(new Vector4(1.0f, 0.0f, 1.0f, 1.0f));
-        var color4 = new NormalizedShort4(1.0f, 0.0f, 1.0f, 1.0f);
+        NormalizedShort4 color1 = new(0.0f, 0.0f, 0.0f, 0.0f);
+        NormalizedShort4 color2 = new(new Vector4(0.0f));
+        NormalizedShort4 color3 = new(new Vector4(1f, 0.0f, 1f, 1f));
+        NormalizedShort4 color4 = new(1f, 0.0f, 1f, 1f);
 
         Assert.Equal(color1, color2);
         Assert.Equal(color3, color4);
@@ -30,10 +31,10 @@ public class NormalizedShort4Tests
     [Fact]
     public void AreNotEqual()
     {
-        var color1 = new NormalizedShort4(0.0f, 0.0f, 0.0f, 0.0f);
-        var color2 = new NormalizedShort4(new Vector4(1.0f));
-        var color3 = new NormalizedShort4(new Vector4(1.0f, 0.0f, 0.0f, 1.0f));
-        var color4 = new NormalizedShort4(1.0f, 1.0f, 0.0f, 1.0f);
+        NormalizedShort4 color1 = new(0.0f, 0.0f, 0.0f, 0.0f);
+        NormalizedShort4 color2 = new(new Vector4(1f));
+        NormalizedShort4 color3 = new(new Vector4(1f, 0.0f, 0.0f, 1f));
+        NormalizedShort4 color4 = new(1f, 1f, 0.0f, 1f);
 
         Assert.NotEqual(color1, color2);
         Assert.NotEqual(color3, color4);
@@ -64,7 +65,7 @@ public class NormalizedShort4Tests
     public void NormalizedShort4_ToScaledVector4()
     {
         // arrange
-        var short4 = new NormalizedShort4(Vector4.One);
+        NormalizedShort4 short4 = new(Vector4.One);
 
         // act
         Vector4 actual = short4.ToScaledVector4();
@@ -80,12 +81,11 @@ public class NormalizedShort4Tests
     public void NormalizedShort4_FromScaledVector4()
     {
         // arrange
-        var pixel = default(NormalizedShort4);
         Vector4 scaled = new NormalizedShort4(Vector4.One).ToScaledVector4();
-        ulong expected = 0x7FFF7FFF7FFF7FFF;
+        const ulong expected = 0x7FFF7FFF7FFF7FFF;
 
         // act
-        pixel.FromScaledVector4(scaled);
+        NormalizedShort4 pixel = NormalizedShort4.FromScaledVector4(scaled);
         ulong actual = pixel.PackedValue;
 
         // assert
@@ -96,124 +96,115 @@ public class NormalizedShort4Tests
     public void NormalizedShort4_FromArgb32()
     {
         // arrange
-        var byte4 = default(NormalizedShort4);
         Vector4 expected = Vector4.One;
 
         // act
-        byte4.FromArgb32(new Argb32(255, 255, 255, 255));
+        NormalizedShort4 pixel = NormalizedShort4.FromArgb32(new Argb32(255, 255, 255, 255));
 
         // assert
-        Assert.Equal(expected, byte4.ToScaledVector4());
+        Assert.Equal(expected, pixel.ToScaledVector4());
     }
 
     [Fact]
     public void NormalizedShort4_FromBgr24()
     {
         // arrange
-        var byte4 = default(NormalizedShort4);
         Vector4 expected = Vector4.One;
 
         // act
-        byte4.FromBgr24(new Bgr24(byte.MaxValue, byte.MaxValue, byte.MaxValue));
+        NormalizedShort4 pixel = NormalizedShort4.FromBgr24(new Bgr24(byte.MaxValue, byte.MaxValue, byte.MaxValue));
 
         // assert
-        Assert.Equal(expected, byte4.ToScaledVector4());
+        Assert.Equal(expected, pixel.ToScaledVector4());
     }
 
     [Fact]
     public void NormalizedShort4_FromGrey8()
     {
         // arrange
-        var byte4 = default(NormalizedShort4);
         Vector4 expected = Vector4.One;
 
         // act
-        byte4.FromL8(new L8(byte.MaxValue));
+        NormalizedShort4 pixel = NormalizedShort4.FromL8(new L8(byte.MaxValue));
 
         // assert
-        Assert.Equal(expected, byte4.ToScaledVector4());
+        Assert.Equal(expected, pixel.ToScaledVector4());
     }
 
     [Fact]
     public void NormalizedShort4_FromGrey16()
     {
         // arrange
-        var byte4 = default(NormalizedShort4);
         Vector4 expected = Vector4.One;
 
         // act
-        byte4.FromL16(new L16(ushort.MaxValue));
+        NormalizedShort4 pixel = NormalizedShort4.FromL16(new L16(ushort.MaxValue));
 
         // assert
-        Assert.Equal(expected, byte4.ToScaledVector4());
+        Assert.Equal(expected, pixel.ToScaledVector4());
     }
 
     [Fact]
     public void NormalizedShort4_FromRgb24()
     {
         // arrange
-        var byte4 = default(NormalizedShort4);
         Vector4 expected = Vector4.One;
 
         // act
-        byte4.FromRgb24(new Rgb24(byte.MaxValue, byte.MaxValue, byte.MaxValue));
+        NormalizedShort4 pixel = NormalizedShort4.FromRgb24(new Rgb24(byte.MaxValue, byte.MaxValue, byte.MaxValue));
 
         // assert
-        Assert.Equal(expected, byte4.ToScaledVector4());
+        Assert.Equal(expected, pixel.ToScaledVector4());
     }
 
     [Fact]
     public void NormalizedShort4_FromRgba32()
     {
         // arrange
-        var byte4 = default(NormalizedShort4);
         Vector4 expected = Vector4.One;
 
         // act
-        byte4.FromRgba32(new Rgba32(255, 255, 255, 255));
+        NormalizedShort4 pixel = NormalizedShort4.FromRgba32(new Rgba32(255, 255, 255, 255));
 
         // assert
-        Assert.Equal(expected, byte4.ToScaledVector4());
+        Assert.Equal(expected, pixel.ToScaledVector4());
     }
 
     [Fact]
     public void NormalizedShort4_FromRgb48()
     {
         // arrange
-        var byte4 = default(NormalizedShort4);
         Vector4 expected = Vector4.One;
 
         // act
-        byte4.FromRgb48(new Rgb48(ushort.MaxValue, ushort.MaxValue, ushort.MaxValue));
+        NormalizedShort4 pixel = NormalizedShort4.FromRgb48(new Rgb48(ushort.MaxValue, ushort.MaxValue, ushort.MaxValue));
 
         // assert
-        Assert.Equal(expected, byte4.ToScaledVector4());
+        Assert.Equal(expected, pixel.ToScaledVector4());
     }
 
     [Fact]
     public void NormalizedShort4_FromRgba64()
     {
         // arrange
-        var byte4 = default(NormalizedShort4);
         Vector4 expected = Vector4.One;
 
         // act
-        byte4.FromRgba64(new Rgba64(ushort.MaxValue, ushort.MaxValue, ushort.MaxValue, ushort.MaxValue));
+        NormalizedShort4 pixel = NormalizedShort4.FromRgba64(new Rgba64(ushort.MaxValue, ushort.MaxValue, ushort.MaxValue, ushort.MaxValue));
 
         // assert
-        Assert.Equal(expected, byte4.ToScaledVector4());
+        Assert.Equal(expected, pixel.ToScaledVector4());
     }
 
     [Fact]
     public void NormalizedShort4_ToRgba32()
     {
         // arrange
-        var byte4 = new NormalizedShort4(byte.MaxValue, byte.MaxValue, byte.MaxValue, byte.MaxValue);
-        var expected = new Rgba32(Vector4.One);
-        var actual = default(Rgba32);
+        NormalizedShort4 pixel = new(byte.MaxValue, byte.MaxValue, byte.MaxValue, byte.MaxValue);
+        Rgba32 expected = new(Vector4.One);
 
         // act
-        byte4.ToRgba32(ref actual);
+        Rgba32 actual = pixel.ToRgba32();
 
         Assert.Equal(expected, actual);
     }
@@ -222,13 +213,30 @@ public class NormalizedShort4Tests
     public void NormalizedShort4_FromBgra5551()
     {
         // arrange
-        var normalizedShort4 = default(NormalizedShort4);
         Vector4 expected = Vector4.One;
 
         // act
-        normalizedShort4.FromBgra5551(new Bgra5551(1.0f, 1.0f, 1.0f, 1.0f));
+        NormalizedShort4 normalizedShort4 = NormalizedShort4.FromBgra5551(new Bgra5551(1f, 1f, 1f, 1f));
 
         // assert
         Assert.Equal(expected, normalizedShort4.ToVector4());
     }
+
+    [Fact]
+    public void NormalizedShort4_PixelInformation()
+    {
+        PixelTypeInfo info = NormalizedShort4.GetPixelTypeInfo();
+        Assert.Equal(Unsafe.SizeOf<NormalizedShort4>() * 8, info.BitsPerPixel);
+        Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
+        Assert.Equal(PixelColorType.RGB | PixelColorType.Alpha, info.ColorType);
+
+        PixelComponentInfo componentInfo = info.ComponentInfo.Value;
+        Assert.Equal(4, componentInfo.ComponentCount);
+        Assert.Equal(0, componentInfo.Padding);
+        Assert.Equal(16, componentInfo.GetComponentPrecision(0));
+        Assert.Equal(16, componentInfo.GetComponentPrecision(1));
+        Assert.Equal(16, componentInfo.GetComponentPrecision(2));
+        Assert.Equal(16, componentInfo.GetComponentPrecision(3));
+        Assert.Equal(16, componentInfo.GetMaximumComponentPrecision());
+    }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/PixelBlenderTests.cs b/tests/ImageSharp.Tests/PixelFormats/PixelBlenderTests.cs
index 68cdf2d63..924e94d92 100644
--- a/tests/ImageSharp.Tests/PixelFormats/PixelBlenderTests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/PixelBlenderTests.cs
@@ -43,15 +43,15 @@ public class PixelBlenderTests
 
     public static TheoryData<Rgba32, Rgba32, float, PixelColorBlendingMode, Rgba32> ColorBlendingExpectedResults = new()
     {
-        { Color.MistyRose, Color.MidnightBlue, 1, PixelColorBlendingMode.Normal, Color.MidnightBlue },
-        { Color.MistyRose, Color.MidnightBlue, 1, PixelColorBlendingMode.Screen, new Rgba32(0xFFEEE7FF) },
-        { Color.MistyRose, Color.MidnightBlue, 1, PixelColorBlendingMode.HardLight, new Rgba32(0xFFC62D32) },
-        { Color.MistyRose, Color.MidnightBlue, 1, PixelColorBlendingMode.Overlay, new Rgba32(0xFFDDCEFF) },
-        { Color.MistyRose, Color.MidnightBlue, 1, PixelColorBlendingMode.Darken, new Rgba32(0xFF701919) },
-        { Color.MistyRose, Color.MidnightBlue, 1, PixelColorBlendingMode.Lighten, new Rgba32(0xFFE1E4FF) },
-        { Color.MistyRose, Color.MidnightBlue, 1, PixelColorBlendingMode.Add, new Rgba32(0xFFFFFDFF) },
-        { Color.MistyRose, Color.MidnightBlue, 1, PixelColorBlendingMode.Subtract, new Rgba32(0xFF71CBE6) },
-        { Color.MistyRose, Color.MidnightBlue, 1, PixelColorBlendingMode.Multiply, new Rgba32(0xFF631619) },
+        { Color.MistyRose.ToPixel<Rgba32>(), Color.MidnightBlue.ToPixel<Rgba32>(), 1, PixelColorBlendingMode.Normal, Color.MidnightBlue.ToPixel<Rgba32>() },
+        { Color.MistyRose.ToPixel<Rgba32>(), Color.MidnightBlue.ToPixel<Rgba32>(), 1, PixelColorBlendingMode.Screen, new Rgba32(0xFFEEE7FF) },
+        { Color.MistyRose.ToPixel<Rgba32>(), Color.MidnightBlue.ToPixel<Rgba32>(), 1, PixelColorBlendingMode.HardLight, new Rgba32(0xFFC62D32) },
+        { Color.MistyRose.ToPixel<Rgba32>(), Color.MidnightBlue.ToPixel<Rgba32>(), 1, PixelColorBlendingMode.Overlay, new Rgba32(0xFFDDCEFF) },
+        { Color.MistyRose.ToPixel<Rgba32>(), Color.MidnightBlue.ToPixel<Rgba32>(), 1, PixelColorBlendingMode.Darken, new Rgba32(0xFF701919) },
+        { Color.MistyRose.ToPixel<Rgba32>(), Color.MidnightBlue.ToPixel<Rgba32>(), 1, PixelColorBlendingMode.Lighten, new Rgba32(0xFFE1E4FF) },
+        { Color.MistyRose.ToPixel<Rgba32>(), Color.MidnightBlue.ToPixel<Rgba32>(), 1, PixelColorBlendingMode.Add, new Rgba32(0xFFFFFDFF) },
+        { Color.MistyRose.ToPixel<Rgba32>(), Color.MidnightBlue.ToPixel<Rgba32>(), 1, PixelColorBlendingMode.Subtract, new Rgba32(0xFF71CBE6) },
+        { Color.MistyRose.ToPixel<Rgba32>(), Color.MidnightBlue.ToPixel<Rgba32>(), 1, PixelColorBlendingMode.Multiply, new Rgba32(0xFF631619) },
     };
 
     [Theory]
@@ -67,18 +67,18 @@ public class PixelBlenderTests
 
     public static TheoryData<Rgba32, Rgba32, float, PixelAlphaCompositionMode, Rgba32> AlphaCompositionExpectedResults = new()
     {
-        { Color.MistyRose, Color.MidnightBlue, 1, PixelAlphaCompositionMode.Clear, new Rgba32(0) },
-        { Color.MistyRose, Color.MidnightBlue, 1, PixelAlphaCompositionMode.Xor, new Rgba32(0) },
-        { Color.MistyRose, Color.MidnightBlue, 1, PixelAlphaCompositionMode.Dest, Color.MistyRose },
-        { Color.MistyRose, Color.MidnightBlue, 1, PixelAlphaCompositionMode.DestAtop, Color.MistyRose },
-        { Color.MistyRose, Color.MidnightBlue, 1, PixelAlphaCompositionMode.DestIn, Color.MistyRose },
-        { Color.MistyRose, Color.MidnightBlue, 1, PixelAlphaCompositionMode.DestOut, new Rgba32(0) },
-        { Color.MistyRose, Color.MidnightBlue, 1, PixelAlphaCompositionMode.DestOver, Color.MistyRose },
-        { Color.MistyRose, Color.MidnightBlue, 1, PixelAlphaCompositionMode.Src, Color.MidnightBlue },
-        { Color.MistyRose, Color.MidnightBlue, 1, PixelAlphaCompositionMode.SrcAtop, Color.MidnightBlue },
-        { Color.MistyRose, Color.MidnightBlue, 1, PixelAlphaCompositionMode.SrcIn, Color.MidnightBlue },
-        { Color.MistyRose, Color.MidnightBlue, 1, PixelAlphaCompositionMode.SrcOut, new Rgba32(0) },
-        { Color.MistyRose, Color.MidnightBlue, 1, PixelAlphaCompositionMode.SrcOver, Color.MidnightBlue },
+        { Color.MistyRose.ToPixel<Rgba32>(), Color.MidnightBlue.ToPixel<Rgba32>(), 1, PixelAlphaCompositionMode.Clear, new Rgba32(0) },
+        { Color.MistyRose.ToPixel<Rgba32>(), Color.MidnightBlue.ToPixel<Rgba32>(), 1, PixelAlphaCompositionMode.Xor, new Rgba32(0) },
+        { Color.MistyRose.ToPixel<Rgba32>(), Color.MidnightBlue.ToPixel<Rgba32>(), 1, PixelAlphaCompositionMode.Dest, Color.MistyRose.ToPixel<Rgba32>() },
+        { Color.MistyRose.ToPixel<Rgba32>(), Color.MidnightBlue.ToPixel<Rgba32>(), 1, PixelAlphaCompositionMode.DestAtop, Color.MistyRose.ToPixel<Rgba32>() },
+        { Color.MistyRose.ToPixel<Rgba32>(), Color.MidnightBlue.ToPixel<Rgba32>(), 1, PixelAlphaCompositionMode.DestIn, Color.MistyRose.ToPixel<Rgba32>() },
+        { Color.MistyRose.ToPixel<Rgba32>(), Color.MidnightBlue.ToPixel<Rgba32>(), 1, PixelAlphaCompositionMode.DestOut, new Rgba32(0) },
+        { Color.MistyRose.ToPixel<Rgba32>(), Color.MidnightBlue.ToPixel<Rgba32>(), 1, PixelAlphaCompositionMode.DestOver, Color.MistyRose.ToPixel<Rgba32>() },
+        { Color.MistyRose.ToPixel<Rgba32>(), Color.MidnightBlue.ToPixel<Rgba32>(), 1, PixelAlphaCompositionMode.Src, Color.MidnightBlue.ToPixel<Rgba32>() },
+        { Color.MistyRose.ToPixel<Rgba32>(), Color.MidnightBlue.ToPixel<Rgba32>(), 1, PixelAlphaCompositionMode.SrcAtop, Color.MidnightBlue.ToPixel<Rgba32>() },
+        { Color.MistyRose.ToPixel<Rgba32>(), Color.MidnightBlue.ToPixel<Rgba32>(), 1, PixelAlphaCompositionMode.SrcIn, Color.MidnightBlue.ToPixel<Rgba32>() },
+        { Color.MistyRose.ToPixel<Rgba32>(), Color.MidnightBlue.ToPixel<Rgba32>(), 1, PixelAlphaCompositionMode.SrcOut, new Rgba32(0) },
+        { Color.MistyRose.ToPixel<Rgba32>(), Color.MidnightBlue.ToPixel<Rgba32>(), 1, PixelAlphaCompositionMode.SrcOver, Color.MidnightBlue.ToPixel<Rgba32>() },
     };
 
     [Theory]
diff --git a/tests/ImageSharp.Tests/PixelFormats/PixelConverterTests.ReferenceImplementations.cs b/tests/ImageSharp.Tests/PixelFormats/PixelConverterTests.ReferenceImplementations.cs
index 006cb9eb6..2a5c5765a 100644
--- a/tests/ImageSharp.Tests/PixelFormats/PixelConverterTests.ReferenceImplementations.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/PixelConverterTests.ReferenceImplementations.cs
@@ -14,7 +14,7 @@ public abstract partial class PixelConverterTests
     {
         public static byte[] MakeRgba32ByteArray(byte r, byte g, byte b, byte a)
         {
-            var buffer = new byte[256];
+            byte[] buffer = new byte[256];
 
             for (int i = 0; i < buffer.Length; i += 4)
             {
@@ -29,7 +29,7 @@ public abstract partial class PixelConverterTests
 
         public static byte[] MakeArgb32ByteArray(byte r, byte g, byte b, byte a)
         {
-            var buffer = new byte[256];
+            byte[] buffer = new byte[256];
 
             for (int i = 0; i < buffer.Length; i += 4)
             {
@@ -44,7 +44,7 @@ public abstract partial class PixelConverterTests
 
         public static byte[] MakeBgra32ByteArray(byte r, byte g, byte b, byte a)
         {
-            var buffer = new byte[256];
+            byte[] buffer = new byte[256];
 
             for (int i = 0; i < buffer.Length; i += 4)
             {
@@ -59,7 +59,7 @@ public abstract partial class PixelConverterTests
 
         public static byte[] MakeAbgr32ByteArray(byte r, byte g, byte b, byte a)
         {
-            var buffer = new byte[256];
+            byte[] buffer = new byte[256];
 
             for (int i = 0; i < buffer.Length; i += 4)
             {
@@ -87,49 +87,18 @@ public abstract partial class PixelConverterTests
 
             if (typeof(TSourcePixel) == typeof(TDestinationPixel))
             {
-                Span<TSourcePixel> uniformDest =
-                    MemoryMarshal.Cast<TDestinationPixel, TSourcePixel>(destinationPixels);
+                Span<TSourcePixel> uniformDest = MemoryMarshal.Cast<TDestinationPixel, TSourcePixel>(destinationPixels);
                 sourcePixels.CopyTo(uniformDest);
                 return;
             }
 
-            // L8 and L16 are special implementations of IPixel in that they do not conform to the
-            // standard RGBA colorspace format and must be converted from RGBA using the special ITU BT709 algorithm.
-            // One of the requirements of FromScaledVector4/ToScaledVector4 is that it unaware of this and
-            // packs/unpacks the pixel without and conversion so we employ custom methods do do this.
-            if (typeof(TDestinationPixel) == typeof(L16))
-            {
-                ref L16 l16Ref = ref MemoryMarshal.GetReference(MemoryMarshal.Cast<TDestinationPixel, L16>(destinationPixels));
-                for (int i = 0; i < count; i++)
-                {
-                    ref TSourcePixel sp = ref Unsafe.Add(ref sourceRef, i);
-                    ref L16 dp = ref Unsafe.Add(ref l16Ref, i);
-                    dp.ConvertFromRgbaScaledVector4(sp.ToScaledVector4());
-                }
-
-                return;
-            }
-
-            if (typeof(TDestinationPixel) == typeof(L8))
-            {
-                ref L8 l8Ref = ref MemoryMarshal.GetReference(MemoryMarshal.Cast<TDestinationPixel, L8>(destinationPixels));
-                for (int i = 0; i < count; i++)
-                {
-                    ref TSourcePixel sp = ref Unsafe.Add(ref sourceRef, i);
-                    ref L8 dp = ref Unsafe.Add(ref l8Ref, i);
-                    dp.ConvertFromRgbaScaledVector4(sp.ToScaledVector4());
-                }
-
-                return;
-            }
-
             // Normal conversion
             ref TDestinationPixel destRef = ref MemoryMarshal.GetReference(destinationPixels);
             for (int i = 0; i < count; i++)
             {
                 ref TSourcePixel sp = ref Unsafe.Add(ref sourceRef, i);
                 ref TDestinationPixel dp = ref Unsafe.Add(ref destRef, i);
-                dp.FromScaledVector4(sp.ToScaledVector4());
+                dp = TDestinationPixel.FromScaledVector4(sp.ToScaledVector4());
             }
         }
     }
diff --git a/tests/ImageSharp.Tests/PixelFormats/PixelOperations/Generated/PixelOperationsTests.Specialized.Generated.cs b/tests/ImageSharp.Tests/PixelFormats/PixelOperations/Generated/PixelOperationsTests.Specialized.Generated.cs
index 5ba5c1bed..b37282927 100644
--- a/tests/ImageSharp.Tests/PixelFormats/PixelOperations/Generated/PixelOperationsTests.Specialized.Generated.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/PixelOperations/Generated/PixelOperationsTests.Specialized.Generated.cs
@@ -1,4 +1,4 @@
-// Copyright (c) Six Labors.
+// Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
 // <auto-generated />
@@ -12,7 +12,7 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats.PixelOperations;
 
 public partial class PixelOperationsTests
 {
-        
+    
     public partial class A8_OperationsTests : PixelOperationsTests<A8>
     {
         public A8_OperationsTests(ITestOutputHelper output)
@@ -20,19 +20,14 @@ public partial class PixelOperationsTests
         {
         }
 
-        protected override PixelOperations<A8> Operations => A8.PixelOperations.Instance;
-
-        [Fact]
-        public void IsSpecialImplementation() => Assert.IsType<A8.PixelOperations>(PixelOperations<A8>.Instance);
-
         [Fact]
         public void PixelTypeInfoHasCorrectAlphaRepresentation()
         {
-            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
+            var alphaRepresentation = A8.GetPixelTypeInfo().AlphaRepresentation;
             Assert.Equal(PixelAlphaRepresentation.Unassociated, alphaRepresentation);
         }
     }
-    
+
     public partial class Argb32_OperationsTests : PixelOperationsTests<Argb32>
     {
         public Argb32_OperationsTests(ITestOutputHelper output)
@@ -40,19 +35,14 @@ public partial class PixelOperationsTests
         {
         }
 
-        protected override PixelOperations<Argb32> Operations => Argb32.PixelOperations.Instance;
-
-        [Fact]
-        public void IsSpecialImplementation() => Assert.IsType<Argb32.PixelOperations>(PixelOperations<Argb32>.Instance);
-
         [Fact]
         public void PixelTypeInfoHasCorrectAlphaRepresentation()
         {
-            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
+            var alphaRepresentation = Argb32.GetPixelTypeInfo().AlphaRepresentation;
             Assert.Equal(PixelAlphaRepresentation.Unassociated, alphaRepresentation);
         }
     }
-    
+
     public partial class Abgr32_OperationsTests : PixelOperationsTests<Abgr32>
     {
         public Abgr32_OperationsTests(ITestOutputHelper output)
@@ -60,19 +50,14 @@ public partial class PixelOperationsTests
         {
         }
 
-        protected override PixelOperations<Abgr32> Operations => Abgr32.PixelOperations.Instance;
-
-        [Fact]
-        public void IsSpecialImplementation() => Assert.IsType<Abgr32.PixelOperations>(PixelOperations<Abgr32>.Instance);
-
         [Fact]
         public void PixelTypeInfoHasCorrectAlphaRepresentation()
         {
-            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
+            var alphaRepresentation = Abgr32.GetPixelTypeInfo().AlphaRepresentation;
             Assert.Equal(PixelAlphaRepresentation.Unassociated, alphaRepresentation);
         }
     }
-    
+
     public partial class Bgr24_OperationsTests : PixelOperationsTests<Bgr24>
     {
         public Bgr24_OperationsTests(ITestOutputHelper output)
@@ -80,19 +65,14 @@ public partial class PixelOperationsTests
         {
         }
 
-        protected override PixelOperations<Bgr24> Operations => Bgr24.PixelOperations.Instance;
-
-        [Fact]
-        public void IsSpecialImplementation() => Assert.IsType<Bgr24.PixelOperations>(PixelOperations<Bgr24>.Instance);
-
         [Fact]
         public void PixelTypeInfoHasCorrectAlphaRepresentation()
         {
-            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
+            var alphaRepresentation = Bgr24.GetPixelTypeInfo().AlphaRepresentation;
             Assert.Equal(PixelAlphaRepresentation.None, alphaRepresentation);
         }
     }
-    
+
     public partial class Bgr565_OperationsTests : PixelOperationsTests<Bgr565>
     {
         public Bgr565_OperationsTests(ITestOutputHelper output)
@@ -100,19 +80,14 @@ public partial class PixelOperationsTests
         {
         }
 
-        protected override PixelOperations<Bgr565> Operations => Bgr565.PixelOperations.Instance;
-
-        [Fact]
-        public void IsSpecialImplementation() => Assert.IsType<Bgr565.PixelOperations>(PixelOperations<Bgr565>.Instance);
-
         [Fact]
         public void PixelTypeInfoHasCorrectAlphaRepresentation()
         {
-            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
+            var alphaRepresentation = Bgr565.GetPixelTypeInfo().AlphaRepresentation;
             Assert.Equal(PixelAlphaRepresentation.None, alphaRepresentation);
         }
     }
-    
+
     public partial class Bgra32_OperationsTests : PixelOperationsTests<Bgra32>
     {
         public Bgra32_OperationsTests(ITestOutputHelper output)
@@ -120,19 +95,14 @@ public partial class PixelOperationsTests
         {
         }
 
-        protected override PixelOperations<Bgra32> Operations => Bgra32.PixelOperations.Instance;
-
-        [Fact]
-        public void IsSpecialImplementation() => Assert.IsType<Bgra32.PixelOperations>(PixelOperations<Bgra32>.Instance);
-
         [Fact]
         public void PixelTypeInfoHasCorrectAlphaRepresentation()
         {
-            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
+            var alphaRepresentation = Bgra32.GetPixelTypeInfo().AlphaRepresentation;
             Assert.Equal(PixelAlphaRepresentation.Unassociated, alphaRepresentation);
         }
     }
-    
+
     public partial class Bgra4444_OperationsTests : PixelOperationsTests<Bgra4444>
     {
         public Bgra4444_OperationsTests(ITestOutputHelper output)
@@ -140,19 +110,14 @@ public partial class PixelOperationsTests
         {
         }
 
-        protected override PixelOperations<Bgra4444> Operations => Bgra4444.PixelOperations.Instance;
-
-        [Fact]
-        public void IsSpecialImplementation() => Assert.IsType<Bgra4444.PixelOperations>(PixelOperations<Bgra4444>.Instance);
-
         [Fact]
         public void PixelTypeInfoHasCorrectAlphaRepresentation()
         {
-            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
+            var alphaRepresentation = Bgra4444.GetPixelTypeInfo().AlphaRepresentation;
             Assert.Equal(PixelAlphaRepresentation.Unassociated, alphaRepresentation);
         }
     }
-    
+
     public partial class Bgra5551_OperationsTests : PixelOperationsTests<Bgra5551>
     {
         public Bgra5551_OperationsTests(ITestOutputHelper output)
@@ -160,19 +125,14 @@ public partial class PixelOperationsTests
         {
         }
 
-        protected override PixelOperations<Bgra5551> Operations => Bgra5551.PixelOperations.Instance;
-
-        [Fact]
-        public void IsSpecialImplementation() => Assert.IsType<Bgra5551.PixelOperations>(PixelOperations<Bgra5551>.Instance);
-
         [Fact]
         public void PixelTypeInfoHasCorrectAlphaRepresentation()
         {
-            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
+            var alphaRepresentation = Bgra5551.GetPixelTypeInfo().AlphaRepresentation;
             Assert.Equal(PixelAlphaRepresentation.Unassociated, alphaRepresentation);
         }
     }
-    
+
     public partial class Byte4_OperationsTests : PixelOperationsTests<Byte4>
     {
         public Byte4_OperationsTests(ITestOutputHelper output)
@@ -180,19 +140,14 @@ public partial class PixelOperationsTests
         {
         }
 
-        protected override PixelOperations<Byte4> Operations => Byte4.PixelOperations.Instance;
-
-        [Fact]
-        public void IsSpecialImplementation() => Assert.IsType<Byte4.PixelOperations>(PixelOperations<Byte4>.Instance);
-
         [Fact]
         public void PixelTypeInfoHasCorrectAlphaRepresentation()
         {
-            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
+            var alphaRepresentation = Byte4.GetPixelTypeInfo().AlphaRepresentation;
             Assert.Equal(PixelAlphaRepresentation.Unassociated, alphaRepresentation);
         }
     }
-    
+
     public partial class HalfSingle_OperationsTests : PixelOperationsTests<HalfSingle>
     {
         public HalfSingle_OperationsTests(ITestOutputHelper output)
@@ -200,19 +155,14 @@ public partial class PixelOperationsTests
         {
         }
 
-        protected override PixelOperations<HalfSingle> Operations => HalfSingle.PixelOperations.Instance;
-
-        [Fact]
-        public void IsSpecialImplementation() => Assert.IsType<HalfSingle.PixelOperations>(PixelOperations<HalfSingle>.Instance);
-
         [Fact]
         public void PixelTypeInfoHasCorrectAlphaRepresentation()
         {
-            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
+            var alphaRepresentation = HalfSingle.GetPixelTypeInfo().AlphaRepresentation;
             Assert.Equal(PixelAlphaRepresentation.None, alphaRepresentation);
         }
     }
-    
+
     public partial class HalfVector2_OperationsTests : PixelOperationsTests<HalfVector2>
     {
         public HalfVector2_OperationsTests(ITestOutputHelper output)
@@ -220,19 +170,14 @@ public partial class PixelOperationsTests
         {
         }
 
-        protected override PixelOperations<HalfVector2> Operations => HalfVector2.PixelOperations.Instance;
-
-        [Fact]
-        public void IsSpecialImplementation() => Assert.IsType<HalfVector2.PixelOperations>(PixelOperations<HalfVector2>.Instance);
-
         [Fact]
         public void PixelTypeInfoHasCorrectAlphaRepresentation()
         {
-            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
+            var alphaRepresentation = HalfVector2.GetPixelTypeInfo().AlphaRepresentation;
             Assert.Equal(PixelAlphaRepresentation.None, alphaRepresentation);
         }
     }
-    
+
     public partial class HalfVector4_OperationsTests : PixelOperationsTests<HalfVector4>
     {
         public HalfVector4_OperationsTests(ITestOutputHelper output)
@@ -240,19 +185,14 @@ public partial class PixelOperationsTests
         {
         }
 
-        protected override PixelOperations<HalfVector4> Operations => HalfVector4.PixelOperations.Instance;
-
-        [Fact]
-        public void IsSpecialImplementation() => Assert.IsType<HalfVector4.PixelOperations>(PixelOperations<HalfVector4>.Instance);
-
         [Fact]
         public void PixelTypeInfoHasCorrectAlphaRepresentation()
         {
-            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
+            var alphaRepresentation = HalfVector4.GetPixelTypeInfo().AlphaRepresentation;
             Assert.Equal(PixelAlphaRepresentation.Unassociated, alphaRepresentation);
         }
     }
-    
+
     public partial class L16_OperationsTests : PixelOperationsTests<L16>
     {
         public L16_OperationsTests(ITestOutputHelper output)
@@ -260,19 +200,14 @@ public partial class PixelOperationsTests
         {
         }
 
-        protected override PixelOperations<L16> Operations => L16.PixelOperations.Instance;
-
-        [Fact]
-        public void IsSpecialImplementation() => Assert.IsType<L16.PixelOperations>(PixelOperations<L16>.Instance);
-
         [Fact]
         public void PixelTypeInfoHasCorrectAlphaRepresentation()
         {
-            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
+            var alphaRepresentation = L16.GetPixelTypeInfo().AlphaRepresentation;
             Assert.Equal(PixelAlphaRepresentation.None, alphaRepresentation);
         }
     }
-    
+
     public partial class L8_OperationsTests : PixelOperationsTests<L8>
     {
         public L8_OperationsTests(ITestOutputHelper output)
@@ -280,19 +215,14 @@ public partial class PixelOperationsTests
         {
         }
 
-        protected override PixelOperations<L8> Operations => L8.PixelOperations.Instance;
-
-        [Fact]
-        public void IsSpecialImplementation() => Assert.IsType<L8.PixelOperations>(PixelOperations<L8>.Instance);
-
         [Fact]
         public void PixelTypeInfoHasCorrectAlphaRepresentation()
         {
-            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
+            var alphaRepresentation = L8.GetPixelTypeInfo().AlphaRepresentation;
             Assert.Equal(PixelAlphaRepresentation.None, alphaRepresentation);
         }
     }
-    
+
     public partial class La16_OperationsTests : PixelOperationsTests<La16>
     {
         public La16_OperationsTests(ITestOutputHelper output)
@@ -300,19 +230,14 @@ public partial class PixelOperationsTests
         {
         }
 
-        protected override PixelOperations<La16> Operations => La16.PixelOperations.Instance;
-
-        [Fact]
-        public void IsSpecialImplementation() => Assert.IsType<La16.PixelOperations>(PixelOperations<La16>.Instance);
-
         [Fact]
         public void PixelTypeInfoHasCorrectAlphaRepresentation()
         {
-            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
+            var alphaRepresentation = La16.GetPixelTypeInfo().AlphaRepresentation;
             Assert.Equal(PixelAlphaRepresentation.Unassociated, alphaRepresentation);
         }
     }
-    
+
     public partial class La32_OperationsTests : PixelOperationsTests<La32>
     {
         public La32_OperationsTests(ITestOutputHelper output)
@@ -320,19 +245,14 @@ public partial class PixelOperationsTests
         {
         }
 
-        protected override PixelOperations<La32> Operations => La32.PixelOperations.Instance;
-
-        [Fact]
-        public void IsSpecialImplementation() => Assert.IsType<La32.PixelOperations>(PixelOperations<La32>.Instance);
-
         [Fact]
         public void PixelTypeInfoHasCorrectAlphaRepresentation()
         {
-            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
+            var alphaRepresentation = La32.GetPixelTypeInfo().AlphaRepresentation;
             Assert.Equal(PixelAlphaRepresentation.Unassociated, alphaRepresentation);
         }
     }
-    
+
     public partial class NormalizedByte2_OperationsTests : PixelOperationsTests<NormalizedByte2>
     {
         public NormalizedByte2_OperationsTests(ITestOutputHelper output)
@@ -340,19 +260,14 @@ public partial class PixelOperationsTests
         {
         }
 
-        protected override PixelOperations<NormalizedByte2> Operations => NormalizedByte2.PixelOperations.Instance;
-
-        [Fact]
-        public void IsSpecialImplementation() => Assert.IsType<NormalizedByte2.PixelOperations>(PixelOperations<NormalizedByte2>.Instance);
-
         [Fact]
         public void PixelTypeInfoHasCorrectAlphaRepresentation()
         {
-            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
+            var alphaRepresentation = NormalizedByte2.GetPixelTypeInfo().AlphaRepresentation;
             Assert.Equal(PixelAlphaRepresentation.None, alphaRepresentation);
         }
     }
-    
+
     public partial class NormalizedByte4_OperationsTests : PixelOperationsTests<NormalizedByte4>
     {
         public NormalizedByte4_OperationsTests(ITestOutputHelper output)
@@ -360,19 +275,14 @@ public partial class PixelOperationsTests
         {
         }
 
-        protected override PixelOperations<NormalizedByte4> Operations => NormalizedByte4.PixelOperations.Instance;
-
-        [Fact]
-        public void IsSpecialImplementation() => Assert.IsType<NormalizedByte4.PixelOperations>(PixelOperations<NormalizedByte4>.Instance);
-
         [Fact]
         public void PixelTypeInfoHasCorrectAlphaRepresentation()
         {
-            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
+            var alphaRepresentation = NormalizedByte4.GetPixelTypeInfo().AlphaRepresentation;
             Assert.Equal(PixelAlphaRepresentation.Unassociated, alphaRepresentation);
         }
     }
-    
+
     public partial class NormalizedShort2_OperationsTests : PixelOperationsTests<NormalizedShort2>
     {
         public NormalizedShort2_OperationsTests(ITestOutputHelper output)
@@ -380,19 +290,14 @@ public partial class PixelOperationsTests
         {
         }
 
-        protected override PixelOperations<NormalizedShort2> Operations => NormalizedShort2.PixelOperations.Instance;
-
-        [Fact]
-        public void IsSpecialImplementation() => Assert.IsType<NormalizedShort2.PixelOperations>(PixelOperations<NormalizedShort2>.Instance);
-
         [Fact]
         public void PixelTypeInfoHasCorrectAlphaRepresentation()
         {
-            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
+            var alphaRepresentation = NormalizedShort2.GetPixelTypeInfo().AlphaRepresentation;
             Assert.Equal(PixelAlphaRepresentation.None, alphaRepresentation);
         }
     }
-    
+
     public partial class NormalizedShort4_OperationsTests : PixelOperationsTests<NormalizedShort4>
     {
         public NormalizedShort4_OperationsTests(ITestOutputHelper output)
@@ -400,19 +305,14 @@ public partial class PixelOperationsTests
         {
         }
 
-        protected override PixelOperations<NormalizedShort4> Operations => NormalizedShort4.PixelOperations.Instance;
-
-        [Fact]
-        public void IsSpecialImplementation() => Assert.IsType<NormalizedShort4.PixelOperations>(PixelOperations<NormalizedShort4>.Instance);
-
         [Fact]
         public void PixelTypeInfoHasCorrectAlphaRepresentation()
         {
-            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
+            var alphaRepresentation = NormalizedShort4.GetPixelTypeInfo().AlphaRepresentation;
             Assert.Equal(PixelAlphaRepresentation.Unassociated, alphaRepresentation);
         }
     }
-    
+
     public partial class Rg32_OperationsTests : PixelOperationsTests<Rg32>
     {
         public Rg32_OperationsTests(ITestOutputHelper output)
@@ -420,19 +320,14 @@ public partial class PixelOperationsTests
         {
         }
 
-        protected override PixelOperations<Rg32> Operations => Rg32.PixelOperations.Instance;
-
-        [Fact]
-        public void IsSpecialImplementation() => Assert.IsType<Rg32.PixelOperations>(PixelOperations<Rg32>.Instance);
-
         [Fact]
         public void PixelTypeInfoHasCorrectAlphaRepresentation()
         {
-            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
+            var alphaRepresentation = Rg32.GetPixelTypeInfo().AlphaRepresentation;
             Assert.Equal(PixelAlphaRepresentation.None, alphaRepresentation);
         }
     }
-    
+
     public partial class Rgb24_OperationsTests : PixelOperationsTests<Rgb24>
     {
         public Rgb24_OperationsTests(ITestOutputHelper output)
@@ -440,19 +335,14 @@ public partial class PixelOperationsTests
         {
         }
 
-        protected override PixelOperations<Rgb24> Operations => Rgb24.PixelOperations.Instance;
-
-        [Fact]
-        public void IsSpecialImplementation() => Assert.IsType<Rgb24.PixelOperations>(PixelOperations<Rgb24>.Instance);
-
         [Fact]
         public void PixelTypeInfoHasCorrectAlphaRepresentation()
         {
-            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
+            var alphaRepresentation = Rgb24.GetPixelTypeInfo().AlphaRepresentation;
             Assert.Equal(PixelAlphaRepresentation.None, alphaRepresentation);
         }
     }
-    
+
     public partial class Rgb48_OperationsTests : PixelOperationsTests<Rgb48>
     {
         public Rgb48_OperationsTests(ITestOutputHelper output)
@@ -460,19 +350,14 @@ public partial class PixelOperationsTests
         {
         }
 
-        protected override PixelOperations<Rgb48> Operations => Rgb48.PixelOperations.Instance;
-
-        [Fact]
-        public void IsSpecialImplementation() => Assert.IsType<Rgb48.PixelOperations>(PixelOperations<Rgb48>.Instance);
-
         [Fact]
         public void PixelTypeInfoHasCorrectAlphaRepresentation()
         {
-            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
+            var alphaRepresentation = Rgb48.GetPixelTypeInfo().AlphaRepresentation;
             Assert.Equal(PixelAlphaRepresentation.None, alphaRepresentation);
         }
     }
-    
+
     public partial class Rgba1010102_OperationsTests : PixelOperationsTests<Rgba1010102>
     {
         public Rgba1010102_OperationsTests(ITestOutputHelper output)
@@ -480,19 +365,14 @@ public partial class PixelOperationsTests
         {
         }
 
-        protected override PixelOperations<Rgba1010102> Operations => Rgba1010102.PixelOperations.Instance;
-
-        [Fact]
-        public void IsSpecialImplementation() => Assert.IsType<Rgba1010102.PixelOperations>(PixelOperations<Rgba1010102>.Instance);
-
         [Fact]
         public void PixelTypeInfoHasCorrectAlphaRepresentation()
         {
-            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
+            var alphaRepresentation = Rgba1010102.GetPixelTypeInfo().AlphaRepresentation;
             Assert.Equal(PixelAlphaRepresentation.Unassociated, alphaRepresentation);
         }
     }
-    
+
     public partial class Rgba32_OperationsTests : PixelOperationsTests<Rgba32>
     {
         public Rgba32_OperationsTests(ITestOutputHelper output)
@@ -500,19 +380,14 @@ public partial class PixelOperationsTests
         {
         }
 
-        protected override PixelOperations<Rgba32> Operations => Rgba32.PixelOperations.Instance;
-
-        [Fact]
-        public void IsSpecialImplementation() => Assert.IsType<Rgba32.PixelOperations>(PixelOperations<Rgba32>.Instance);
-
         [Fact]
         public void PixelTypeInfoHasCorrectAlphaRepresentation()
         {
-            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
+            var alphaRepresentation = Rgba32.GetPixelTypeInfo().AlphaRepresentation;
             Assert.Equal(PixelAlphaRepresentation.Unassociated, alphaRepresentation);
         }
     }
-    
+
     public partial class Rgba64_OperationsTests : PixelOperationsTests<Rgba64>
     {
         public Rgba64_OperationsTests(ITestOutputHelper output)
@@ -520,19 +395,14 @@ public partial class PixelOperationsTests
         {
         }
 
-        protected override PixelOperations<Rgba64> Operations => Rgba64.PixelOperations.Instance;
-
-        [Fact]
-        public void IsSpecialImplementation() => Assert.IsType<Rgba64.PixelOperations>(PixelOperations<Rgba64>.Instance);
-
         [Fact]
         public void PixelTypeInfoHasCorrectAlphaRepresentation()
         {
-            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
+            var alphaRepresentation = Rgba64.GetPixelTypeInfo().AlphaRepresentation;
             Assert.Equal(PixelAlphaRepresentation.Unassociated, alphaRepresentation);
         }
     }
-    
+
     public partial class RgbaVector_OperationsTests : PixelOperationsTests<RgbaVector>
     {
         public RgbaVector_OperationsTests(ITestOutputHelper output)
@@ -540,19 +410,14 @@ public partial class PixelOperationsTests
         {
         }
 
-        protected override PixelOperations<RgbaVector> Operations => RgbaVector.PixelOperations.Instance;
-
-        [Fact]
-        public void IsSpecialImplementation() => Assert.IsType<RgbaVector.PixelOperations>(PixelOperations<RgbaVector>.Instance);
-
         [Fact]
         public void PixelTypeInfoHasCorrectAlphaRepresentation()
         {
-            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
+            var alphaRepresentation = RgbaVector.GetPixelTypeInfo().AlphaRepresentation;
             Assert.Equal(PixelAlphaRepresentation.Unassociated, alphaRepresentation);
         }
     }
-    
+
     public partial class Short2_OperationsTests : PixelOperationsTests<Short2>
     {
         public Short2_OperationsTests(ITestOutputHelper output)
@@ -560,19 +425,14 @@ public partial class PixelOperationsTests
         {
         }
 
-        protected override PixelOperations<Short2> Operations => Short2.PixelOperations.Instance;
-
-        [Fact]
-        public void IsSpecialImplementation() => Assert.IsType<Short2.PixelOperations>(PixelOperations<Short2>.Instance);
-
         [Fact]
         public void PixelTypeInfoHasCorrectAlphaRepresentation()
         {
-            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
+            var alphaRepresentation = Short2.GetPixelTypeInfo().AlphaRepresentation;
             Assert.Equal(PixelAlphaRepresentation.None, alphaRepresentation);
         }
     }
-    
+
     public partial class Short4_OperationsTests : PixelOperationsTests<Short4>
     {
         public Short4_OperationsTests(ITestOutputHelper output)
@@ -580,15 +440,10 @@ public partial class PixelOperationsTests
         {
         }
 
-        protected override PixelOperations<Short4> Operations => Short4.PixelOperations.Instance;
-
-        [Fact]
-        public void IsSpecialImplementation() => Assert.IsType<Short4.PixelOperations>(PixelOperations<Short4>.Instance);
-
         [Fact]
         public void PixelTypeInfoHasCorrectAlphaRepresentation()
         {
-            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
+            var alphaRepresentation = Short4.GetPixelTypeInfo().AlphaRepresentation;
             Assert.Equal(PixelAlphaRepresentation.Unassociated, alphaRepresentation);
         }
     }
diff --git a/tests/ImageSharp.Tests/PixelFormats/PixelOperations/Generated/_Common.ttinclude b/tests/ImageSharp.Tests/PixelFormats/PixelOperations/Generated/_Common.ttinclude
index 0e7b1f335..90cb3a866 100644
--- a/tests/ImageSharp.Tests/PixelFormats/PixelOperations/Generated/_Common.ttinclude
+++ b/tests/ImageSharp.Tests/PixelFormats/PixelOperations/Generated/_Common.ttinclude
@@ -70,7 +70,7 @@ using Xunit.Abstractions;
 
     void GenerateSpecializedClass(string pixelType, string alpha)
     {#>
-    
+
     public partial class <#=pixelType#>_OperationsTests : PixelOperationsTests<<#=pixelType#>>
     {
         public <#=pixelType#>_OperationsTests(ITestOutputHelper output)
@@ -78,15 +78,10 @@ using Xunit.Abstractions;
         {
         }
 
-        protected override PixelOperations<<#=pixelType#>> Operations => <#=pixelType#>.PixelOperations.Instance;
-
-        [Fact]
-        public void IsSpecialImplementation() => Assert.IsType<<#=pixelType#>.PixelOperations>(PixelOperations<<#=pixelType#>>.Instance);
-
         [Fact]
         public void PixelTypeInfoHasCorrectAlphaRepresentation()
         {
-            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
+            var alphaRepresentation = <#=pixelType#>.GetPixelTypeInfo().AlphaRepresentation;
             Assert.Equal(<#=alpha#>, alphaRepresentation);
         }
     }
diff --git a/tests/ImageSharp.Tests/PixelFormats/PixelOperations/PixelOperationsTests.cs b/tests/ImageSharp.Tests/PixelFormats/PixelOperations/PixelOperationsTests.cs
index a9b3ee9a4..68c282d8a 100644
--- a/tests/ImageSharp.Tests/PixelFormats/PixelOperations/PixelOperationsTests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/PixelOperations/PixelOperationsTests.cs
@@ -39,49 +39,49 @@ public abstract class PixelOperationsTests<TPixel> : MeasureFixture
     }
 
     public static TheoryData<int> ArraySizesData =>
-        new TheoryData<int>
-            {
-                0,
-                1,
-                2,
-                7,
-                16,
-                512,
-                513,
-                514,
-                515,
-                516,
-                517,
-                518,
-                519,
-                520,
-                521,
-                522,
-                523,
-                524,
-                525,
-                526,
-                527,
-                528,
-                1111
-            };
+        new()
+        {
+            0,
+            1,
+            2,
+            7,
+            16,
+            512,
+            513,
+            514,
+            515,
+            516,
+            517,
+            518,
+            519,
+            520,
+            521,
+            522,
+            523,
+            524,
+            525,
+            526,
+            527,
+            528,
+            1111
+        };
 
     protected Configuration Configuration => Configuration.Default;
 
     protected virtual PixelOperations<TPixel> Operations { get; } = PixelOperations<TPixel>.Instance;
 
-    protected bool HasUnassociatedAlpha => this.Operations.GetPixelTypeInfo().AlphaRepresentation == PixelAlphaRepresentation.Unassociated;
+    protected bool HasUnassociatedAlpha => TPixel.GetPixelTypeInfo().AlphaRepresentation == PixelAlphaRepresentation.Unassociated;
 
     internal static TPixel[] CreateExpectedPixelData(Vector4[] source, RefAction<Vector4> vectorModifier = null)
     {
-        var expected = new TPixel[source.Length];
+        TPixel[] expected = new TPixel[source.Length];
 
         for (int i = 0; i < expected.Length; i++)
         {
             Vector4 v = source[i];
             vectorModifier?.Invoke(ref v);
 
-            expected[i].FromVector4(v);
+            expected[i] = TPixel.FromVector4(v);
         }
 
         return expected;
@@ -89,14 +89,14 @@ public abstract class PixelOperationsTests<TPixel> : MeasureFixture
 
     internal static TPixel[] CreateScaledExpectedPixelData(Vector4[] source, RefAction<Vector4> vectorModifier = null)
     {
-        var expected = new TPixel[source.Length];
+        TPixel[] expected = new TPixel[source.Length];
 
         for (int i = 0; i < expected.Length; i++)
         {
             Vector4 v = source[i];
             vectorModifier?.Invoke(ref v);
 
-            expected[i].FromScaledVector4(v);
+            expected[i] = TPixel.FromScaledVector4(v);
         }
 
         return expected;
@@ -105,7 +105,7 @@ public abstract class PixelOperationsTests<TPixel> : MeasureFixture
     [Fact]
     public void PixelTypeInfoHasCorrectBitsPerPixel()
     {
-        int bits = this.Operations.GetPixelTypeInfo().BitsPerPixel;
+        int bits = TPixel.GetPixelTypeInfo().BitsPerPixel;
         Assert.Equal(Unsafe.SizeOf<TPixel>() * 8, bits);
     }
 
@@ -114,18 +114,16 @@ public abstract class PixelOperationsTests<TPixel> : MeasureFixture
     {
         // We use 0 - 255 as we have pixel formats that store
         // the alpha component in less than 8 bits.
-        const byte Alpha = byte.MinValue;
-        const byte NoAlpha = byte.MaxValue;
+        const byte alpha = byte.MinValue;
+        const byte noAlpha = byte.MaxValue;
 
-        TPixel pixel = default;
-        pixel.FromRgba32(new Rgba32(0, 0, 0, Alpha));
+        TPixel pixel = TPixel.FromRgba32(new Rgba32(0, 0, 0, alpha));
 
-        Rgba32 dest = default;
-        pixel.ToRgba32(ref dest);
+        Rgba32 dest = pixel.ToRgba32();
 
-        bool hasAlpha = this.Operations.GetPixelTypeInfo().AlphaRepresentation != PixelAlphaRepresentation.None;
+        bool hasAlpha = TPixel.GetPixelTypeInfo().AlphaRepresentation != PixelAlphaRepresentation.None;
 
-        byte expectedAlpha = hasAlpha ? Alpha : NoAlpha;
+        byte expectedAlpha = hasAlpha ? alpha : noAlpha;
         Assert.Equal(expectedAlpha, dest.A);
     }
 
@@ -355,7 +353,7 @@ public abstract class PixelOperationsTests<TPixel> : MeasureFixture
     {
         const int count = 2134;
         TPixel[] source = CreatePixelTestData(count);
-        var expected = new TDestPixel[count];
+        TDestPixel[] expected = new TDestPixel[count];
 
         PixelConverterTests.ReferenceImplementations.To<TPixel, TDestPixel>(this.Configuration, source, expected);
 
@@ -476,13 +474,13 @@ public abstract class PixelOperationsTests<TPixel> : MeasureFixture
     public void FromArgb32Bytes(int count)
     {
         byte[] source = CreateByteTestData(count * 4);
-        var expected = new TPixel[count];
+        TPixel[] expected = new TPixel[count];
 
         for (int i = 0; i < count; i++)
         {
             int i4 = i * 4;
 
-            expected[i].FromArgb32(new Argb32(source[i4 + 1], source[i4 + 2], source[i4 + 3], source[i4 + 0]));
+            expected[i] = TPixel.FromArgb32(new Argb32(source[i4 + 1], source[i4 + 2], source[i4 + 3], source[i4 + 0]));
         }
 
         TestOperation(
@@ -497,12 +495,11 @@ public abstract class PixelOperationsTests<TPixel> : MeasureFixture
     {
         TPixel[] source = CreatePixelTestData(count);
         byte[] expected = new byte[count * 4];
-        var argb = default(Argb32);
 
         for (int i = 0; i < count; i++)
         {
             int i4 = i * 4;
-            argb.FromScaledVector4(source[i].ToScaledVector4());
+            Argb32 argb = Argb32.FromScaledVector4(source[i].ToScaledVector4());
 
             expected[i4] = argb.A;
             expected[i4 + 1] = argb.R;
@@ -521,13 +518,13 @@ public abstract class PixelOperationsTests<TPixel> : MeasureFixture
     public void FromBgr24Bytes(int count)
     {
         byte[] source = CreateByteTestData(count * 3);
-        var expected = new TPixel[count];
+        TPixel[] expected = new TPixel[count];
 
         for (int i = 0; i < count; i++)
         {
             int i3 = i * 3;
 
-            expected[i].FromBgr24(new Bgr24(source[i3 + 2], source[i3 + 1], source[i3]));
+            expected[i] = TPixel.FromBgr24(new Bgr24(source[i3 + 2], source[i3 + 1], source[i3]));
         }
 
         TestOperation(
@@ -542,12 +539,11 @@ public abstract class PixelOperationsTests<TPixel> : MeasureFixture
     {
         TPixel[] source = CreatePixelTestData(count);
         byte[] expected = new byte[count * 3];
-        var bgr = default(Bgr24);
 
         for (int i = 0; i < count; i++)
         {
             int i3 = i * 3;
-            bgr.FromScaledVector4(source[i].ToScaledVector4());
+            Bgr24 bgr = Bgr24.FromScaledVector4(source[i].ToScaledVector4());
             expected[i3] = bgr.B;
             expected[i3 + 1] = bgr.G;
             expected[i3 + 2] = bgr.R;
@@ -564,13 +560,13 @@ public abstract class PixelOperationsTests<TPixel> : MeasureFixture
     public void FromBgra32Bytes(int count)
     {
         byte[] source = CreateByteTestData(count * 4);
-        var expected = new TPixel[count];
+        TPixel[] expected = new TPixel[count];
 
         for (int i = 0; i < count; i++)
         {
             int i4 = i * 4;
 
-            expected[i].FromBgra32(new Bgra32(source[i4 + 2], source[i4 + 1], source[i4 + 0], source[i4 + 3]));
+            expected[i] = TPixel.FromBgra32(new Bgra32(source[i4 + 2], source[i4 + 1], source[i4 + 0], source[i4 + 3]));
         }
 
         TestOperation(
@@ -585,12 +581,11 @@ public abstract class PixelOperationsTests<TPixel> : MeasureFixture
     {
         TPixel[] source = CreatePixelTestData(count);
         byte[] expected = new byte[count * 4];
-        var bgra = default(Bgra32);
 
         for (int i = 0; i < count; i++)
         {
             int i4 = i * 4;
-            bgra.FromScaledVector4(source[i].ToScaledVector4());
+            Bgra32 bgra = Bgra32.FromScaledVector4(source[i].ToScaledVector4());
             expected[i4] = bgra.B;
             expected[i4 + 1] = bgra.G;
             expected[i4 + 2] = bgra.R;
@@ -608,13 +603,13 @@ public abstract class PixelOperationsTests<TPixel> : MeasureFixture
     public void FromAbgr32Bytes(int count)
     {
         byte[] source = CreateByteTestData(count * 4);
-        var expected = new TPixel[count];
+        TPixel[] expected = new TPixel[count];
 
         for (int i = 0; i < count; i++)
         {
             int i4 = i * 4;
 
-            expected[i].FromAbgr32(new Abgr32(source[i4 + 3], source[i4 + 2], source[i4 + 1], source[i4 + 0]));
+            expected[i] = TPixel.FromAbgr32(new Abgr32(source[i4 + 3], source[i4 + 2], source[i4 + 1], source[i4 + 0]));
         }
 
         TestOperation(
@@ -629,12 +624,11 @@ public abstract class PixelOperationsTests<TPixel> : MeasureFixture
     {
         TPixel[] source = CreatePixelTestData(count);
         byte[] expected = new byte[count * 4];
-        var abgr = default(Abgr32);
 
         for (int i = 0; i < count; i++)
         {
             int i4 = i * 4;
-            abgr.FromScaledVector4(source[i].ToScaledVector4());
+            Abgr32 abgr = Abgr32.FromScaledVector4(source[i].ToScaledVector4());
             expected[i4] = abgr.A;
             expected[i4 + 1] = abgr.B;
             expected[i4 + 2] = abgr.G;
@@ -653,14 +647,14 @@ public abstract class PixelOperationsTests<TPixel> : MeasureFixture
     {
         int size = Unsafe.SizeOf<Bgra5551>();
         byte[] source = CreateByteTestData(count * size);
-        var expected = new TPixel[count];
+        TPixel[] expected = new TPixel[count];
 
         for (int i = 0; i < count; i++)
         {
             int offset = i * size;
 
             Bgra5551 bgra = MemoryMarshal.Cast<byte, Bgra5551>(source.AsSpan().Slice(offset, size))[0];
-            expected[i].FromBgra5551(bgra);
+            expected[i] = TPixel.FromBgra5551(bgra);
         }
 
         TestOperation(
@@ -676,12 +670,11 @@ public abstract class PixelOperationsTests<TPixel> : MeasureFixture
         int size = Unsafe.SizeOf<Bgra5551>();
         TPixel[] source = CreatePixelTestData(count);
         byte[] expected = new byte[count * size];
-        Bgra5551 bgra = default;
 
         for (int i = 0; i < count; i++)
         {
             int offset = i * size;
-            bgra.FromScaledVector4(source[i].ToScaledVector4());
+            Bgra5551 bgra = Bgra5551.FromScaledVector4(source[i].ToScaledVector4());
             OctetBytes bytes = Unsafe.As<Bgra5551, OctetBytes>(ref bgra);
             expected[offset] = bytes[0];
             expected[offset + 1] = bytes[1];
@@ -699,11 +692,11 @@ public abstract class PixelOperationsTests<TPixel> : MeasureFixture
     {
         byte[] sourceBytes = CreateByteTestData(count);
         L8[] source = sourceBytes.Select(b => new L8(b)).ToArray();
-        var expected = new TPixel[count];
+        TPixel[] expected = new TPixel[count];
 
         for (int i = 0; i < count; i++)
         {
-            expected[i].FromL8(source[i]);
+            expected[i] = TPixel.FromL8(source[i]);
         }
 
         TestOperation(
@@ -717,11 +710,11 @@ public abstract class PixelOperationsTests<TPixel> : MeasureFixture
     public void ToL8(int count)
     {
         TPixel[] source = CreatePixelTestData(count);
-        var expected = new L8[count];
+        L8[] expected = new L8[count];
 
         for (int i = 0; i < count; i++)
         {
-            expected[i].FromScaledVector4(source[i].ToScaledVector4());
+            expected[i] = L8.FromScaledVector4(source[i].ToScaledVector4());
         }
 
         TestOperation(
@@ -734,18 +727,13 @@ public abstract class PixelOperationsTests<TPixel> : MeasureFixture
     [MemberData(nameof(ArraySizesData))]
     public void FromL16(int count)
     {
-        L16[] source = CreateVector4TestData(count).Select(v =>
-        {
-            L16 g = default;
-            g.FromVector4(v);
-            return g;
-        }).ToArray();
+        L16[] source = CreateVector4TestData(count).Select(L16.FromVector4).ToArray();
 
-        var expected = new TPixel[count];
+        TPixel[] expected = new TPixel[count];
 
         for (int i = 0; i < count; i++)
         {
-            expected[i].FromL16(source[i]);
+            expected[i] = TPixel.FromL16(source[i]);
         }
 
         TestOperation(
@@ -759,11 +747,11 @@ public abstract class PixelOperationsTests<TPixel> : MeasureFixture
     public void ToL16(int count)
     {
         TPixel[] source = CreatePixelTestData(count);
-        var expected = new L16[count];
+        L16[] expected = new L16[count];
 
         for (int i = 0; i < count; i++)
         {
-            expected[i].FromScaledVector4(source[i].ToScaledVector4());
+            expected[i] = L16.FromScaledVector4(source[i].ToScaledVector4());
         }
 
         TestOperation(
@@ -778,14 +766,14 @@ public abstract class PixelOperationsTests<TPixel> : MeasureFixture
     {
         int size = Unsafe.SizeOf<La16>();
         byte[] source = CreateByteTestData(count * size);
-        var expected = new TPixel[count];
+        TPixel[] expected = new TPixel[count];
 
         for (int i = 0; i < count; i++)
         {
             int offset = i * size;
 
             La16 la = MemoryMarshal.Cast<byte, La16>(source.AsSpan().Slice(offset, size))[0];
-            expected[i].FromLa16(la);
+            expected[i] = TPixel.FromLa16(la);
         }
 
         TestOperation(
@@ -801,12 +789,11 @@ public abstract class PixelOperationsTests<TPixel> : MeasureFixture
         int size = Unsafe.SizeOf<La16>();
         TPixel[] source = CreatePixelTestData(count);
         byte[] expected = new byte[count * size];
-        La16 la = default;
 
         for (int i = 0; i < count; i++)
         {
             int offset = i * size;
-            la.FromScaledVector4(source[i].ToScaledVector4());
+            La16 la = La16.FromScaledVector4(source[i].ToScaledVector4());
             OctetBytes bytes = Unsafe.As<La16, OctetBytes>(ref la);
             expected[offset] = bytes[0];
             expected[offset + 1] = bytes[1];
@@ -824,14 +811,14 @@ public abstract class PixelOperationsTests<TPixel> : MeasureFixture
     {
         int size = Unsafe.SizeOf<La32>();
         byte[] source = CreateByteTestData(count * size);
-        var expected = new TPixel[count];
+        TPixel[] expected = new TPixel[count];
 
         for (int i = 0; i < count; i++)
         {
             int offset = i * size;
 
             La32 la = MemoryMarshal.Cast<byte, La32>(source.AsSpan().Slice(offset, size))[0];
-            expected[i].FromLa32(la);
+            expected[i] = TPixel.FromLa32(la);
         }
 
         TestOperation(
@@ -847,12 +834,11 @@ public abstract class PixelOperationsTests<TPixel> : MeasureFixture
         int size = Unsafe.SizeOf<La32>();
         TPixel[] source = CreatePixelTestData(count);
         byte[] expected = new byte[count * size];
-        La32 la = default;
 
         for (int i = 0; i < count; i++)
         {
             int offset = i * size;
-            la.FromScaledVector4(source[i].ToScaledVector4());
+            La32 la = La32.FromScaledVector4(source[i].ToScaledVector4());
             OctetBytes bytes = Unsafe.As<La32, OctetBytes>(ref la);
             expected[offset] = bytes[0];
             expected[offset + 1] = bytes[1];
@@ -871,13 +857,13 @@ public abstract class PixelOperationsTests<TPixel> : MeasureFixture
     public void FromRgb24Bytes(int count)
     {
         byte[] source = CreateByteTestData(count * 3);
-        var expected = new TPixel[count];
+        TPixel[] expected = new TPixel[count];
 
         for (int i = 0; i < count; i++)
         {
             int i3 = i * 3;
 
-            expected[i].FromRgb24(new Rgb24(source[i3 + 0], source[i3 + 1], source[i3 + 2]));
+            expected[i] = TPixel.FromRgb24(new Rgb24(source[i3 + 0], source[i3 + 1], source[i3 + 2]));
         }
 
         TestOperation(
@@ -892,12 +878,11 @@ public abstract class PixelOperationsTests<TPixel> : MeasureFixture
     {
         TPixel[] source = CreatePixelTestData(count);
         byte[] expected = new byte[count * 3];
-        var rgb = default(Rgb24);
 
         for (int i = 0; i < count; i++)
         {
             int i3 = i * 3;
-            rgb.FromScaledVector4(source[i].ToScaledVector4());
+            Rgb24 rgb = Rgb24.FromScaledVector4(source[i].ToScaledVector4());
             expected[i3] = rgb.R;
             expected[i3 + 1] = rgb.G;
             expected[i3 + 2] = rgb.B;
@@ -914,13 +899,13 @@ public abstract class PixelOperationsTests<TPixel> : MeasureFixture
     public void FromRgba32Bytes(int count)
     {
         byte[] source = CreateByteTestData(count * 4);
-        var expected = new TPixel[count];
+        TPixel[] expected = new TPixel[count];
 
         for (int i = 0; i < count; i++)
         {
             int i4 = i * 4;
 
-            expected[i].FromRgba32(new Rgba32(source[i4 + 0], source[i4 + 1], source[i4 + 2], source[i4 + 3]));
+            expected[i] = TPixel.FromRgba32(new Rgba32(source[i4 + 0], source[i4 + 1], source[i4 + 2], source[i4 + 3]));
         }
 
         TestOperation(
@@ -935,12 +920,11 @@ public abstract class PixelOperationsTests<TPixel> : MeasureFixture
     {
         TPixel[] source = CreatePixelTestData(count);
         byte[] expected = new byte[count * 4];
-        var rgba = default(Rgba32);
 
         for (int i = 0; i < count; i++)
         {
             int i4 = i * 4;
-            rgba.FromScaledVector4(source[i].ToScaledVector4());
+            Rgba32 rgba = Rgba32.FromScaledVector4(source[i].ToScaledVector4());
             expected[i4] = rgba.R;
             expected[i4 + 1] = rgba.G;
             expected[i4 + 2] = rgba.B;
@@ -959,12 +943,12 @@ public abstract class PixelOperationsTests<TPixel> : MeasureFixture
     {
         byte[] source = CreateByteTestData(count * 6);
         Span<byte> sourceSpan = source.AsSpan();
-        var expected = new TPixel[count];
+        TPixel[] expected = new TPixel[count];
 
         for (int i = 0; i < count; i++)
         {
             int i6 = i * 6;
-            expected[i].FromRgb48(MemoryMarshal.Cast<byte, Rgb48>(sourceSpan.Slice(i6, 6))[0]);
+            expected[i] = TPixel.FromRgb48(MemoryMarshal.Cast<byte, Rgb48>(sourceSpan.Slice(i6, 6))[0]);
         }
 
         TestOperation(
@@ -979,12 +963,11 @@ public abstract class PixelOperationsTests<TPixel> : MeasureFixture
     {
         TPixel[] source = CreatePixelTestData(count);
         byte[] expected = new byte[count * 6];
-        Rgb48 rgb = default;
 
         for (int i = 0; i < count; i++)
         {
             int i6 = i * 6;
-            rgb.FromScaledVector4(source[i].ToScaledVector4());
+            Rgb48 rgb = Rgb48.FromScaledVector4(source[i].ToScaledVector4());
             OctetBytes rgb48Bytes = Unsafe.As<Rgb48, OctetBytes>(ref rgb);
             expected[i6] = rgb48Bytes[0];
             expected[i6 + 1] = rgb48Bytes[1];
@@ -1006,12 +989,12 @@ public abstract class PixelOperationsTests<TPixel> : MeasureFixture
     {
         byte[] source = CreateByteTestData(count * 8);
         Span<byte> sourceSpan = source.AsSpan();
-        var expected = new TPixel[count];
+        TPixel[] expected = new TPixel[count];
 
         for (int i = 0; i < count; i++)
         {
             int i8 = i * 8;
-            expected[i].FromRgba64(MemoryMarshal.Cast<byte, Rgba64>(sourceSpan.Slice(i8, 8))[0]);
+            expected[i] = TPixel.FromRgba64(MemoryMarshal.Cast<byte, Rgba64>(sourceSpan.Slice(i8, 8))[0]);
         }
 
         TestOperation(
@@ -1026,12 +1009,11 @@ public abstract class PixelOperationsTests<TPixel> : MeasureFixture
     {
         TPixel[] source = CreatePixelTestData(count);
         byte[] expected = new byte[count * 8];
-        Rgba64 rgba = default;
 
         for (int i = 0; i < count; i++)
         {
             int i8 = i * 8;
-            rgba.FromScaledVector4(source[i].ToScaledVector4());
+            Rgba64 rgba = Rgba64.FromScaledVector4(source[i].ToScaledVector4());
             OctetBytes rgba64Bytes = Unsafe.As<Rgba64, OctetBytes>(ref rgba);
             expected[i8] = rgba64Bytes[0];
             expected[i8 + 1] = rgba64Bytes[1];
@@ -1060,11 +1042,11 @@ public abstract class PixelOperationsTests<TPixel> : MeasureFixture
 
     internal static Vector4[] CreateExpectedVector4Data(TPixel[] source, RefAction<Vector4> vectorModifier = null)
     {
-        var expected = new Vector4[source.Length];
+        Vector4[] expected = new Vector4[source.Length];
 
         for (int i = 0; i < expected.Length; i++)
         {
-            var v = source[i].ToVector4();
+            Vector4 v = source[i].ToVector4();
 
             vectorModifier?.Invoke(ref v);
 
@@ -1076,7 +1058,7 @@ public abstract class PixelOperationsTests<TPixel> : MeasureFixture
 
     internal static Vector4[] CreateExpectedScaledVector4Data(TPixel[] source, RefAction<Vector4> vectorModifier = null)
     {
-        var expected = new Vector4[source.Length];
+        Vector4[] expected = new Vector4[source.Length];
 
         for (int i = 0; i < expected.Length; i++)
         {
@@ -1098,7 +1080,7 @@ public abstract class PixelOperationsTests<TPixel> : MeasureFixture
         where TSource : struct
         where TDest : struct
     {
-        using (var buffers = new TestBuffers<TSource, TDest>(source, expected, preferExactComparison))
+        using (TestBuffers<TSource, TDest> buffers = new(source, expected, preferExactComparison))
         {
             action(buffers.SourceBuffer, buffers.ActualDestBuffer);
             buffers.Verify();
@@ -1107,8 +1089,8 @@ public abstract class PixelOperationsTests<TPixel> : MeasureFixture
 
     internal static Vector4[] CreateVector4TestData(int length, RefAction<Vector4> vectorModifier = null)
     {
-        var result = new Vector4[length];
-        var rnd = new Random(42); // Deterministic random values
+        Vector4[] result = new Vector4[length];
+        Random rnd = new(42); // Deterministic random values
 
         for (int i = 0; i < result.Length; i++)
         {
@@ -1123,9 +1105,9 @@ public abstract class PixelOperationsTests<TPixel> : MeasureFixture
 
     internal static TPixel[] CreatePixelTestData(int length, RefAction<Vector4> vectorModifier = null)
     {
-        var result = new TPixel[length];
+        TPixel[] result = new TPixel[length];
 
-        var rnd = new Random(42); // Deterministic random values
+        Random rnd = new(42); // Deterministic random values
 
         for (int i = 0; i < result.Length; i++)
         {
@@ -1133,7 +1115,7 @@ public abstract class PixelOperationsTests<TPixel> : MeasureFixture
 
             vectorModifier?.Invoke(ref v);
 
-            result[i].FromVector4(v);
+            result[i] = TPixel.FromVector4(v);
         }
 
         return result;
@@ -1141,9 +1123,9 @@ public abstract class PixelOperationsTests<TPixel> : MeasureFixture
 
     internal static TPixel[] CreateScaledPixelTestData(int length, RefAction<Vector4> vectorModifier = null)
     {
-        var result = new TPixel[length];
+        TPixel[] result = new TPixel[length];
 
-        var rnd = new Random(42); // Deterministic random values
+        Random rnd = new(42); // Deterministic random values
 
         for (int i = 0; i < result.Length; i++)
         {
@@ -1151,7 +1133,7 @@ public abstract class PixelOperationsTests<TPixel> : MeasureFixture
 
             vectorModifier?.Invoke(ref v);
 
-            result[i].FromScaledVector4(v);
+            result[i] = TPixel.FromScaledVector4(v);
         }
 
         return result;
@@ -1160,7 +1142,7 @@ public abstract class PixelOperationsTests<TPixel> : MeasureFixture
     internal static byte[] CreateByteTestData(int length, int seed = 42)
     {
         byte[] result = new byte[length];
-        var rnd = new Random(seed); // Deterministic random values
+        Random rnd = new(seed); // Deterministic random values
 
         for (int i = 0; i < result.Length; i++)
         {
@@ -1171,7 +1153,7 @@ public abstract class PixelOperationsTests<TPixel> : MeasureFixture
     }
 
     internal static Vector4 GetScaledVector(Random rnd)
-        => new Vector4((float)rnd.NextDouble(), (float)rnd.NextDouble(), (float)rnd.NextDouble(), (float)rnd.NextDouble());
+        => new((float)rnd.NextDouble(), (float)rnd.NextDouble(), (float)rnd.NextDouble(), (float)rnd.NextDouble());
 
     [StructLayout(LayoutKind.Sequential)]
     internal unsafe struct OctetBytes
@@ -1219,7 +1201,7 @@ public abstract class PixelOperationsTests<TPixel> : MeasureFixture
             {
                 Span<Vector4> expected = MemoryMarshal.Cast<TDest, Vector4>(this.ExpectedDestBuffer.AsSpan());
                 Span<Vector4> actual = MemoryMarshal.Cast<TDest, Vector4>(this.ActualDestBuffer.GetSpan());
-                var comparer = new ApproximateFloatComparer(TestEnvironment.Is64BitProcess ? 0.0001F : 0.001F);
+                ApproximateFloatComparer comparer = new(TestEnvironment.Is64BitProcess ? 0.0001F : 0.001F);
 
                 for (int i = 0; i < count; i++)
                 {
@@ -1230,11 +1212,11 @@ public abstract class PixelOperationsTests<TPixel> : MeasureFixture
             {
                 Span<TDest> expected = this.ExpectedDestBuffer.AsSpan();
                 Span<TDest> actual = this.ActualDestBuffer.GetSpan();
-                var comparer = new ApproximateFloatComparer(TestEnvironment.Is64BitProcess ? 0.0001F : 0.001F);
+                ApproximateFloatComparer comparer = new(TestEnvironment.Is64BitProcess ? 0.0001F : 0.001F);
 
                 for (int i = 0; i < count; i++)
                 {
-                    Assert.Equal((IPixel)expected[i], (IPixel)actual[i], comparer);
+                    Assert.Equal(((IPixel)expected[i]).ToScaledVector4(), ((IPixel)actual[i]).ToScaledVector4(), comparer);
                 }
             }
             else
@@ -1249,7 +1231,7 @@ public abstract class PixelOperationsTests<TPixel> : MeasureFixture
             }
         }
 
-        // TODO: We really need a PixelTypeInfo.BitsPerComponent property!!
+        // TODO: Figure out a means to use PixelTypeInfo here.
         private static bool IsComplexPixel() => default(TDest) switch
         {
             HalfSingle or HalfVector2 or L16 or La32 or NormalizedShort2 or Rg32 or Short2 => true,
diff --git a/tests/ImageSharp.Tests/PixelFormats/Rg32Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Rg32Tests.cs
index 2900b0d29..b2790469a 100644
--- a/tests/ImageSharp.Tests/PixelFormats/Rg32Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/Rg32Tests.cs
@@ -2,6 +2,7 @@
 // Licensed under the Six Labors Split License.
 
 using System.Numerics;
+using System.Runtime.CompilerServices;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Tests.PixelFormats;
@@ -12,8 +13,8 @@ public class Rg32Tests
     [Fact]
     public void Rg32_PackedValues()
     {
-        float x = 0xb6dc;
-        float y = 0xA59f;
+        const float x = 0xb6dc;
+        const float y = 0xA59f;
         Assert.Equal(0xa59fb6dc, new Rg32(x / 0xffff, y / 0xffff).PackedValue);
         Assert.Equal(6554U, new Rg32(0.1f, -0.3f).PackedValue);
 
@@ -33,7 +34,7 @@ public class Rg32Tests
     public void Rg32_ToScaledVector4()
     {
         // arrange
-        var rg32 = new Rg32(Vector2.One);
+        Rg32 rg32 = new(Vector2.One);
 
         // act
         Vector4 actual = rg32.ToScaledVector4();
@@ -49,13 +50,12 @@ public class Rg32Tests
     public void Rg32_FromScaledVector4()
     {
         // arrange
-        var rg32 = new Rg32(Vector2.One);
-        var pixel = default(Rg32);
-        uint expected = 0xFFFFFFFF;
+        Rg32 rg32 = new(Vector2.One);
+        const uint expected = 0xFFFFFFFF;
 
         // act
         Vector4 scaled = rg32.ToScaledVector4();
-        pixel.FromScaledVector4(scaled);
+        Rg32 pixel = Rg32.FromScaledVector4(scaled);
         uint actual = pixel.PackedValue;
 
         // assert
@@ -66,11 +66,10 @@ public class Rg32Tests
     public void Rg32_FromBgra5551()
     {
         // arrange
-        var rg32 = new Rg32(Vector2.One);
-        uint expected = 0xFFFFFFFF;
+        const uint expected = 0xFFFFFFFF;
 
         // act
-        rg32.FromBgra5551(new Bgra5551(1.0f, 1.0f, 1.0f, 1.0f));
+        Rg32 rg32 = Rg32.FromBgra5551(new Bgra5551(1f, 1f, 1f, 1f));
 
         // assert
         Assert.Equal(expected, rg32.PackedValue);
@@ -82,4 +81,20 @@ public class Rg32Tests
         Assert.Equal(Vector2.Zero, new Rg32(Vector2.One * -1234.0f).ToVector2());
         Assert.Equal(Vector2.One, new Rg32(Vector2.One * 1234.0f).ToVector2());
     }
+
+    [Fact]
+    public void Rg32_PixelInformation()
+    {
+        PixelTypeInfo info = Rg32.GetPixelTypeInfo();
+        Assert.Equal(Unsafe.SizeOf<Rg32>() * 8, info.BitsPerPixel);
+        Assert.Equal(PixelAlphaRepresentation.None, info.AlphaRepresentation);
+        Assert.Equal(PixelColorType.Red | PixelColorType.Green, info.ColorType);
+
+        PixelComponentInfo componentInfo = info.ComponentInfo.Value;
+        Assert.Equal(2, componentInfo.ComponentCount);
+        Assert.Equal(0, componentInfo.Padding);
+        Assert.Equal(16, componentInfo.GetComponentPrecision(0));
+        Assert.Equal(16, componentInfo.GetComponentPrecision(1));
+        Assert.Equal(16, componentInfo.GetMaximumComponentPrecision());
+    }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/Rgb24Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Rgb24Tests.cs
index 2d1be8ab4..6364378c1 100644
--- a/tests/ImageSharp.Tests/PixelFormats/Rgb24Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/Rgb24Tests.cs
@@ -2,6 +2,7 @@
 // Licensed under the Six Labors Split License.
 
 using System.Numerics;
+using System.Runtime.CompilerServices;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Tests.PixelFormats;
@@ -21,7 +22,7 @@ public class Rgb24Tests
     [MemberData(nameof(ColorData))]
     public void Constructor(byte r, byte g, byte b)
     {
-        var p = new Rgb24(r, g, b);
+        Rgb24 p = new(r, g, b);
 
         Assert.Equal(r, p.R);
         Assert.Equal(g, p.G);
@@ -31,7 +32,7 @@ public class Rgb24Tests
     [Fact]
     public unsafe void ByteLayoutIsSequentialRgb()
     {
-        var color = new Rgb24(1, 2, 3);
+        Rgb24 color = new(1, 2, 3);
         byte* ptr = (byte*)&color;
 
         Assert.Equal(1, ptr[0]);
@@ -43,8 +44,8 @@ public class Rgb24Tests
     [MemberData(nameof(ColorData))]
     public void Equals_WhenTrue(byte r, byte g, byte b)
     {
-        var x = new Rgb24(r, g, b);
-        var y = new Rgb24(r, g, b);
+        Rgb24 x = new(r, g, b);
+        Rgb24 y = new(r, g, b);
 
         Assert.True(x.Equals(y));
         Assert.True(x.Equals((object)y));
@@ -57,8 +58,8 @@ public class Rgb24Tests
     [InlineData(1, 255, 0, 0, 255, 0)]
     public void Equals_WhenFalse(byte r1, byte g1, byte b1, byte r2, byte g2, byte b2)
     {
-        var a = new Rgb24(r1, g1, b1);
-        var b = new Rgb24(r2, g2, b2);
+        Rgb24 a = new(r1, g1, b1);
+        Rgb24 b = new(r2, g2, b2);
 
         Assert.False(a.Equals(b));
         Assert.False(a.Equals((object)b));
@@ -67,8 +68,7 @@ public class Rgb24Tests
     [Fact]
     public void FromRgba32()
     {
-        var rgb = default(Rgb24);
-        rgb.FromRgba32(new Rgba32(1, 2, 3, 4));
+        Rgb24 rgb = Rgb24.FromRgba32(new Rgba32(1, 2, 3, 4));
 
         Assert.Equal(1, rgb.R);
         Assert.Equal(2, rgb.G);
@@ -84,8 +84,7 @@ public class Rgb24Tests
     [Fact]
     public void FromVector4()
     {
-        var rgb = default(Rgb24);
-        rgb.FromVector4(Vec(1, 2, 3, 4));
+        Rgb24 rgb = Rgb24.FromVector4(Vec(1, 2, 3, 4));
 
         Assert.Equal(1, rgb.R);
         Assert.Equal(2, rgb.G);
@@ -95,7 +94,7 @@ public class Rgb24Tests
     [Fact]
     public void ToVector4()
     {
-        var rgb = new Rgb24(1, 2, 3);
+        Rgb24 rgb = new(1, 2, 3);
 
         Assert.Equal(Vec(1, 2, 3), rgb.ToVector4());
     }
@@ -104,12 +103,11 @@ public class Rgb24Tests
     public void ToRgba32()
     {
         // arrange
-        var rgb = new Rgb24(1, 2, 3);
-        Rgba32 rgba = default;
-        var expected = new Rgba32(1, 2, 3, 255);
+        Rgb24 rgb = new(1, 2, 3);
+        Rgba32 expected = new(1, 2, 3, 255);
 
         // act
-        rgb.ToRgba32(ref rgba);
+        Rgba32 rgba = rgb.ToRgba32();
 
         // assert
         Assert.Equal(expected, rgba);
@@ -118,15 +116,29 @@ public class Rgb24Tests
     [Fact]
     public void Rgb24_FromBgra5551()
     {
-        // arrange
-        var rgb = new Rgb24(255, 255, 255);
-
         // act
-        rgb.FromBgra5551(new Bgra5551(1.0f, 1.0f, 1.0f, 1.0f));
+        Rgb24 rgb = Rgb24.FromBgra5551(new Bgra5551(1.0f, 1.0f, 1.0f, 1.0f));
 
         // assert
         Assert.Equal(255, rgb.R);
         Assert.Equal(255, rgb.G);
         Assert.Equal(255, rgb.B);
     }
+
+    [Fact]
+    public void Rgb24_PixelInformation()
+    {
+        PixelTypeInfo info = Rgb24.GetPixelTypeInfo();
+        Assert.Equal(Unsafe.SizeOf<Rgb24>() * 8, info.BitsPerPixel);
+        Assert.Equal(PixelAlphaRepresentation.None, info.AlphaRepresentation);
+        Assert.Equal(PixelColorType.RGB, info.ColorType);
+
+        PixelComponentInfo componentInfo = info.ComponentInfo.Value;
+        Assert.Equal(3, componentInfo.ComponentCount);
+        Assert.Equal(0, componentInfo.Padding);
+        Assert.Equal(8, componentInfo.GetComponentPrecision(0));
+        Assert.Equal(8, componentInfo.GetComponentPrecision(1));
+        Assert.Equal(8, componentInfo.GetComponentPrecision(2));
+        Assert.Equal(8, componentInfo.GetMaximumComponentPrecision());
+    }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/Rgb48Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Rgb48Tests.cs
index d8a61940b..764627ee3 100644
--- a/tests/ImageSharp.Tests/PixelFormats/Rgb48Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/Rgb48Tests.cs
@@ -2,6 +2,7 @@
 // Licensed under the Six Labors Split License.
 
 using System.Numerics;
+using System.Runtime.CompilerServices;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Tests.PixelFormats;
@@ -12,7 +13,7 @@ public class Rgb48Tests
     [Fact]
     public void Rgb48_Values()
     {
-        var rgb = new Rgba64(5243, 9830, 19660, 29491);
+        Rgba64 rgb = new(5243, 9830, 19660, 29491);
 
         Assert.Equal(5243, rgb.R);
         Assert.Equal(9830, rgb.G);
@@ -32,13 +33,12 @@ public class Rgb48Tests
     public void Rgb48_FromScaledVector4()
     {
         // arrange
-        var pixel = default(Rgb48);
-        var short3 = new Rgb48(ushort.MaxValue, ushort.MaxValue, ushort.MaxValue);
-        var expected = new Rgb48(ushort.MaxValue, ushort.MaxValue, ushort.MaxValue);
+        Rgb48 short3 = new(ushort.MaxValue, ushort.MaxValue, ushort.MaxValue);
+        Rgb48 expected = new(ushort.MaxValue, ushort.MaxValue, ushort.MaxValue);
 
         // act
         Vector4 scaled = short3.ToScaledVector4();
-        pixel.FromScaledVector4(scaled);
+        Rgb48 pixel = Rgb48.FromScaledVector4(scaled);
 
         // assert
         Assert.Equal(expected, pixel);
@@ -48,12 +48,11 @@ public class Rgb48Tests
     public void Rgb48_ToRgba32()
     {
         // arrange
-        var rgba48 = new Rgb48(5140, 9766, 19532);
-        var expected = new Rgba32(20, 38, 76, 255);
+        Rgb48 rgba48 = new(5140, 9766, 19532);
+        Rgba32 expected = new(20, 38, 76, 255);
 
         // act
-        Rgba32 actual = default;
-        rgba48.ToRgba32(ref actual);
+        Rgba32 actual = rgba48.ToRgba32();
 
         // assert
         Assert.Equal(expected, actual);
@@ -63,15 +62,31 @@ public class Rgb48Tests
     public void Rgb48_FromBgra5551()
     {
         // arrange
-        var rgb = default(Rgb48);
-        ushort expected = ushort.MaxValue;
+        const ushort expected = ushort.MaxValue;
 
         // act
-        rgb.FromBgra5551(new Bgra5551(1.0f, 1.0f, 1.0f, 1.0f));
+        Rgb48 rgb = Rgb48.FromBgra5551(new Bgra5551(1f, 1f, 1f, 1f));
 
         // assert
         Assert.Equal(expected, rgb.R);
         Assert.Equal(expected, rgb.G);
         Assert.Equal(expected, rgb.B);
     }
+
+    [Fact]
+    public void Rgb48_PixelInformation()
+    {
+        PixelTypeInfo info = Rgb48.GetPixelTypeInfo();
+        Assert.Equal(Unsafe.SizeOf<Rgb48>() * 8, info.BitsPerPixel);
+        Assert.Equal(PixelAlphaRepresentation.None, info.AlphaRepresentation);
+        Assert.Equal(PixelColorType.RGB, info.ColorType);
+
+        PixelComponentInfo componentInfo = info.ComponentInfo.Value;
+        Assert.Equal(3, componentInfo.ComponentCount);
+        Assert.Equal(0, componentInfo.Padding);
+        Assert.Equal(16, componentInfo.GetComponentPrecision(0));
+        Assert.Equal(16, componentInfo.GetComponentPrecision(1));
+        Assert.Equal(16, componentInfo.GetComponentPrecision(2));
+        Assert.Equal(16, componentInfo.GetMaximumComponentPrecision());
+    }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/Rgba1010102Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Rgba1010102Tests.cs
index 0c28b35c6..79a1aefc9 100644
--- a/tests/ImageSharp.Tests/PixelFormats/Rgba1010102Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/Rgba1010102Tests.cs
@@ -2,6 +2,7 @@
 // Licensed under the Six Labors Split License.
 
 using System.Numerics;
+using System.Runtime.CompilerServices;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Tests.PixelFormats;
@@ -15,10 +16,10 @@ public class Rgba1010102Tests
     [Fact]
     public void AreEqual()
     {
-        var color1 = new Rgba1010102(0.0f, 0.0f, 0.0f, 0.0f);
-        var color2 = new Rgba1010102(new Vector4(0.0f));
-        var color3 = new Rgba1010102(new Vector4(1.0f, 0.0f, 1.0f, 1.0f));
-        var color4 = new Rgba1010102(1.0f, 0.0f, 1.0f, 1.0f);
+        Rgba1010102 color1 = new(0.0f, 0.0f, 0.0f, 0.0f);
+        Rgba1010102 color2 = new(new Vector4(0.0f));
+        Rgba1010102 color3 = new(new Vector4(1f, 0.0f, 1f, 1f));
+        Rgba1010102 color4 = new(1f, 0.0f, 1f, 1f);
 
         Assert.Equal(color1, color2);
         Assert.Equal(color3, color4);
@@ -30,10 +31,10 @@ public class Rgba1010102Tests
     [Fact]
     public void AreNotEqual()
     {
-        var color1 = new Rgba1010102(0.0f, 0.0f, 0.0f, 0.0f);
-        var color2 = new Rgba1010102(new Vector4(1.0f));
-        var color3 = new Rgba1010102(new Vector4(1.0f, 0.0f, 0.0f, 1.0f));
-        var color4 = new Rgba1010102(1.0f, 1.0f, 0.0f, 1.0f);
+        Rgba1010102 color1 = new(0.0f, 0.0f, 0.0f, 0.0f);
+        Rgba1010102 color2 = new(new Vector4(1f));
+        Rgba1010102 color3 = new(new Vector4(1f, 0.0f, 0.0f, 1f));
+        Rgba1010102 color4 = new(1f, 1f, 0.0f, 1f);
 
         Assert.NotEqual(color1, color2);
         Assert.NotEqual(color3, color4);
@@ -42,10 +43,10 @@ public class Rgba1010102Tests
     [Fact]
     public void Rgba1010102_PackedValue()
     {
-        float x = 0x2db;
-        float y = 0x36d;
-        float z = 0x3b7;
-        float w = 0x1;
+        const float x = 0x2db;
+        const float y = 0x36d;
+        const float z = 0x3b7;
+        const float w = 0x1;
         Assert.Equal(0x7B7DB6DBU, new Rgba1010102(x / 0x3ff, y / 0x3ff, z / 0x3ff, w / 3).PackedValue);
 
         Assert.Equal(536871014U, new Rgba1010102(0.1f, -0.3f, 0.5f, -0.7f).PackedValue);
@@ -66,7 +67,7 @@ public class Rgba1010102Tests
     public void Rgba1010102_ToScaledVector4()
     {
         // arrange
-        var rgba = new Rgba1010102(Vector4.One);
+        Rgba1010102 rgba = new(Vector4.One);
 
         // act
         Vector4 actual = rgba.ToScaledVector4();
@@ -82,13 +83,12 @@ public class Rgba1010102Tests
     public void Rgba1010102_FromScaledVector4()
     {
         // arrange
-        var rgba = new Rgba1010102(Vector4.One);
-        var actual = default(Rgba1010102);
-        uint expected = 0xFFFFFFFF;
+        Rgba1010102 rgba = new(Vector4.One);
+        const uint expected = 0xFFFFFFFF;
 
         // act
         Vector4 scaled = rgba.ToScaledVector4();
-        actual.FromScaledVector4(scaled);
+        Rgba1010102 actual = Rgba1010102.FromScaledVector4(scaled);
 
         // assert
         Assert.Equal(expected, actual.PackedValue);
@@ -98,11 +98,10 @@ public class Rgba1010102Tests
     public void Rgba1010102_FromBgra5551()
     {
         // arrange
-        var rgba = new Rgba1010102(Vector4.One);
-        uint expected = 0xFFFFFFFF;
+        const uint expected = 0xFFFFFFFF;
 
         // act
-        rgba.FromBgra5551(new Bgra5551(1.0f, 1.0f, 1.0f, 1.0f));
+        Rgba1010102 rgba = Rgba1010102.FromBgra5551(new Bgra5551(1f, 1f, 1f, 1f));
 
         // assert
         Assert.Equal(expected, rgba.PackedValue);
@@ -112,11 +111,10 @@ public class Rgba1010102Tests
     public void Rgba1010102_FromArgb32()
     {
         // arrange
-        var rgba = default(Rgba1010102);
-        uint expectedPackedValue = uint.MaxValue;
+        const uint expectedPackedValue = uint.MaxValue;
 
         // act
-        rgba.FromArgb32(new Argb32(255, 255, 255, 255));
+        Rgba1010102 rgba = Rgba1010102.FromArgb32(new Argb32(255, 255, 255, 255));
 
         // assert
         Assert.Equal(expectedPackedValue, rgba.PackedValue);
@@ -126,14 +124,12 @@ public class Rgba1010102Tests
     public void Rgba1010102_FromRgba32()
     {
         // arrange
-        var rgba1 = default(Rgba1010102);
-        var rgba2 = default(Rgba1010102);
-        uint expectedPackedValue1 = uint.MaxValue;
-        uint expectedPackedValue2 = 0xFFF003FF;
+        const uint expectedPackedValue1 = uint.MaxValue;
+        const uint expectedPackedValue2 = 0xFFF003FF;
 
         // act
-        rgba1.FromRgba32(new Rgba32(255, 255, 255, 255));
-        rgba2.FromRgba32(new Rgba32(255, 0, 255, 255));
+        Rgba1010102 rgba1 = Rgba1010102.FromRgba32(new Rgba32(255, 255, 255, 255));
+        Rgba1010102 rgba2 = Rgba1010102.FromRgba32(new Rgba32(255, 0, 255, 255));
 
         // assert
         Assert.Equal(expectedPackedValue1, rgba1.PackedValue);
@@ -144,11 +140,10 @@ public class Rgba1010102Tests
     public void Rgba1010102_FromBgr24()
     {
         // arrange
-        var rgba = default(Rgba1010102);
-        uint expectedPackedValue = uint.MaxValue;
+        const uint expectedPackedValue = uint.MaxValue;
 
         // act
-        rgba.FromBgr24(new Bgr24(byte.MaxValue, byte.MaxValue, byte.MaxValue));
+        Rgba1010102 rgba = Rgba1010102.FromBgr24(new Bgr24(byte.MaxValue, byte.MaxValue, byte.MaxValue));
 
         // assert
         Assert.Equal(expectedPackedValue, rgba.PackedValue);
@@ -158,11 +153,10 @@ public class Rgba1010102Tests
     public void Rgba1010102_FromGrey8()
     {
         // arrange
-        var rgba = default(Rgba1010102);
-        uint expectedPackedValue = uint.MaxValue;
+        const uint expectedPackedValue = uint.MaxValue;
 
         // act
-        rgba.FromL8(new L8(byte.MaxValue));
+        Rgba1010102 rgba = Rgba1010102.FromL8(new L8(byte.MaxValue));
 
         // assert
         Assert.Equal(expectedPackedValue, rgba.PackedValue);
@@ -172,11 +166,10 @@ public class Rgba1010102Tests
     public void Rgba1010102_FromGrey16()
     {
         // arrange
-        var rgba = default(Rgba1010102);
-        uint expectedPackedValue = uint.MaxValue;
+        const uint expectedPackedValue = uint.MaxValue;
 
         // act
-        rgba.FromL16(new L16(ushort.MaxValue));
+        Rgba1010102 rgba = Rgba1010102.FromL16(new L16(ushort.MaxValue));
 
         // assert
         Assert.Equal(expectedPackedValue, rgba.PackedValue);
@@ -186,11 +179,10 @@ public class Rgba1010102Tests
     public void Rgba1010102_FromRgb24()
     {
         // arrange
-        var rgba = default(Rgba1010102);
-        uint expectedPackedValue = uint.MaxValue;
+        const uint expectedPackedValue = uint.MaxValue;
 
         // act
-        rgba.FromRgb24(new Rgb24(byte.MaxValue, byte.MaxValue, byte.MaxValue));
+        Rgba1010102 rgba = Rgba1010102.FromRgb24(new Rgb24(byte.MaxValue, byte.MaxValue, byte.MaxValue));
 
         // assert
         Assert.Equal(expectedPackedValue, rgba.PackedValue);
@@ -200,11 +192,10 @@ public class Rgba1010102Tests
     public void Rgba1010102_FromRgb48()
     {
         // arrange
-        var rgba = default(Rgba1010102);
-        uint expectedPackedValue = uint.MaxValue;
+        const uint expectedPackedValue = uint.MaxValue;
 
         // act
-        rgba.FromRgb48(new Rgb48(ushort.MaxValue, ushort.MaxValue, ushort.MaxValue));
+        Rgba1010102 rgba = Rgba1010102.FromRgb48(new Rgb48(ushort.MaxValue, ushort.MaxValue, ushort.MaxValue));
 
         // assert
         Assert.Equal(expectedPackedValue, rgba.PackedValue);
@@ -214,11 +205,10 @@ public class Rgba1010102Tests
     public void Rgba1010102_FromRgba64()
     {
         // arrange
-        var rgba = default(Rgba1010102);
-        uint expectedPackedValue = uint.MaxValue;
+        const uint expectedPackedValue = uint.MaxValue;
 
         // act
-        rgba.FromRgba64(new Rgba64(ushort.MaxValue, ushort.MaxValue, ushort.MaxValue, ushort.MaxValue));
+        Rgba1010102 rgba = Rgba1010102.FromRgba64(new Rgba64(ushort.MaxValue, ushort.MaxValue, ushort.MaxValue, ushort.MaxValue));
 
         // assert
         Assert.Equal(expectedPackedValue, rgba.PackedValue);
@@ -235,14 +225,31 @@ public class Rgba1010102Tests
     public void Rgba1010102_ToRgba32()
     {
         // arrange
-        var rgba = new Rgba1010102(0.1f, -0.3f, 0.5f, -0.7f);
-        var expected = new Rgba32(25, 0, 128, 0);
+        Rgba1010102 rgba = new(0.1f, -0.3f, 0.5f, -0.7f);
+        Rgba32 expected = new(25, 0, 128, 0);
 
         // act
-        Rgba32 actual = default;
-        rgba.ToRgba32(ref actual);
+        Rgba32 actual = rgba.ToRgba32();
 
         // assert
         Assert.Equal(expected, actual);
     }
+
+    [Fact]
+    public void Rgba1010102_PixelInformation()
+    {
+        PixelTypeInfo info = Rgba1010102.GetPixelTypeInfo();
+        Assert.Equal(Unsafe.SizeOf<Rgba1010102>() * 8, info.BitsPerPixel);
+        Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
+        Assert.Equal(PixelColorType.RGB | PixelColorType.Alpha, info.ColorType);
+
+        PixelComponentInfo componentInfo = info.ComponentInfo.Value;
+        Assert.Equal(4, componentInfo.ComponentCount);
+        Assert.Equal(0, componentInfo.Padding);
+        Assert.Equal(10, componentInfo.GetComponentPrecision(0));
+        Assert.Equal(10, componentInfo.GetComponentPrecision(1));
+        Assert.Equal(10, componentInfo.GetComponentPrecision(2));
+        Assert.Equal(2, componentInfo.GetComponentPrecision(3));
+        Assert.Equal(10, componentInfo.GetMaximumComponentPrecision());
+    }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/Rgba32Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Rgba32Tests.cs
index 64903f65b..6d56185ec 100644
--- a/tests/ImageSharp.Tests/PixelFormats/Rgba32Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/Rgba32Tests.cs
@@ -2,6 +2,7 @@
 // Licensed under the Six Labors Split License.
 
 using System.Numerics;
+using System.Runtime.CompilerServices;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Tests.PixelFormats;
@@ -18,12 +19,12 @@ public class Rgba32Tests
     [Fact]
     public void AreEqual()
     {
-        var color1 = new Rgba32(0, 0, 0);
-        var color2 = new Rgba32(0, 0, 0, 1F);
-        var color3 = Rgba32.ParseHex("#000");
-        var color4 = Rgba32.ParseHex("#000F");
-        var color5 = Rgba32.ParseHex("#000000");
-        var color6 = Rgba32.ParseHex("#000000FF");
+        Rgba32 color1 = new(0, 0, 0);
+        Rgba32 color2 = new(0, 0, 0, 1F);
+        Rgba32 color3 = Rgba32.ParseHex("#000");
+        Rgba32 color4 = Rgba32.ParseHex("#000F");
+        Rgba32 color5 = Rgba32.ParseHex("#000000");
+        Rgba32 color6 = Rgba32.ParseHex("#000000FF");
 
         Assert.Equal(color1, color2);
         Assert.Equal(color1, color3);
@@ -38,11 +39,11 @@ public class Rgba32Tests
     [Fact]
     public void AreNotEqual()
     {
-        var color1 = new Rgba32(255, 0, 0, 255);
-        var color2 = new Rgba32(0, 0, 0, 255);
-        var color3 = Rgba32.ParseHex("#000");
-        var color4 = Rgba32.ParseHex("#000000");
-        var color5 = Rgba32.ParseHex("#FF000000");
+        Rgba32 color1 = new(255, 0, 0, 255);
+        Rgba32 color2 = new(0, 0, 0, 255);
+        Rgba32 color3 = Rgba32.ParseHex("#000");
+        Rgba32 color4 = Rgba32.ParseHex("#000000");
+        Rgba32 color5 = Rgba32.ParseHex("#FF000000");
 
         Assert.NotEqual(color1, color2);
         Assert.NotEqual(color1, color3);
@@ -56,25 +57,25 @@ public class Rgba32Tests
     [Fact]
     public void ConstructorAssignsProperties()
     {
-        var color1 = new Rgba32(1, .1f, .133f, .864f);
+        Rgba32 color1 = new(1, .1f, .133f, .864f);
         Assert.Equal(255, color1.R);
         Assert.Equal((byte)Math.Round(.1f * 255), color1.G);
         Assert.Equal((byte)Math.Round(.133f * 255), color1.B);
         Assert.Equal((byte)Math.Round(.864f * 255), color1.A);
 
-        var color2 = new Rgba32(1, .1f, .133f);
+        Rgba32 color2 = new(1, .1f, .133f);
         Assert.Equal(255, color2.R);
         Assert.Equal(Math.Round(.1f * 255), color2.G);
         Assert.Equal(Math.Round(.133f * 255), color2.B);
         Assert.Equal(255, color2.A);
 
-        var color4 = new Rgba32(new Vector3(1, .1f, .133f));
+        Rgba32 color4 = new(new Vector3(1, .1f, .133f));
         Assert.Equal(255, color4.R);
         Assert.Equal(Math.Round(.1f * 255), color4.G);
         Assert.Equal(Math.Round(.133f * 255), color4.B);
         Assert.Equal(255, color4.A);
 
-        var color5 = new Rgba32(new Vector4(1, .1f, .133f, .5f));
+        Rgba32 color5 = new(new Vector4(1, .1f, .133f, .5f));
         Assert.Equal(255, color5.R);
         Assert.Equal(Math.Round(.1f * 255), color5.G);
         Assert.Equal(Math.Round(.133f * 255), color5.B);
@@ -88,7 +89,7 @@ public class Rgba32Tests
     public void FromAndToHex()
     {
         // 8 digit hex matches css4 spec. RRGGBBAA
-        var color = Rgba32.ParseHex("#AABBCCDD"); // 170, 187, 204, 221
+        Rgba32 color = Rgba32.ParseHex("#AABBCCDD"); // 170, 187, 204, 221
         Assert.Equal(170, color.R);
         Assert.Equal(187, color.G);
         Assert.Equal(204, color.B);
@@ -111,7 +112,7 @@ public class Rgba32Tests
     [Fact]
     public unsafe void ByteLayout()
     {
-        var color = new Rgba32(1, 2, 3, 4);
+        Rgba32 color = new(1, 2, 3, 4);
         byte* colorBase = (byte*)&color;
         Assert.Equal(1, colorBase[0]);
         Assert.Equal(2, colorBase[1]);
@@ -146,7 +147,7 @@ public class Rgba32Tests
     public void Rgba32_ToScaledVector4()
     {
         // arrange
-        var rgba = new Rgba32(Vector4.One);
+        Rgba32 rgba = new(Vector4.One);
 
         // act
         Vector4 actual = rgba.ToScaledVector4();
@@ -162,13 +163,12 @@ public class Rgba32Tests
     public void Rgba32_FromScaledVector4()
     {
         // arrange
-        var rgba = new Rgba32(Vector4.One);
-        var actual = default(Rgba32);
-        uint expected = 0xFFFFFFFF;
+        Rgba32 rgba = new(Vector4.One);
+        const uint expected = 0xFFFFFFFF;
 
         // act
         Vector4 scaled = rgba.ToScaledVector4();
-        actual.FromScaledVector4(scaled);
+        Rgba32 actual = Rgba32.FromScaledVector4(scaled);
 
         // assert
         Assert.Equal(expected, actual.PackedValue);
@@ -185,12 +185,11 @@ public class Rgba32Tests
     public void Rgba32_ToRgba32()
     {
         // arrange
-        var rgba = new Rgba32(+0.1f, -0.3f, +0.5f, -0.7f);
-        var actual = default(Rgba32);
-        var expected = new Rgba32(0x1a, 0, 0x80, 0);
+        Rgba32 rgba = new(+0.1f, -0.3f, +0.5f, -0.7f);
+        Rgba32 expected = new(0x1a, 0, 0x80, 0);
 
         // act
-        actual.FromRgba32(rgba);
+        Rgba32 actual = Rgba32.FromRgba32(rgba);
 
         // assert
         Assert.Equal(expected, actual);
@@ -200,13 +199,11 @@ public class Rgba32Tests
     public void Rgba32_FromRgba32_ToRgba32()
     {
         // arrange
-        var rgba = default(Rgba32);
-        var actual = default(Rgba32);
-        var expected = new Rgba32(0x1a, 0, 0x80, 0);
+        Rgba32 expected = new(0x1a, 0, 0x80, 0);
 
         // act
-        rgba.FromRgba32(expected);
-        actual.FromRgba32(rgba);
+        Rgba32 rgba = Rgba32.FromRgba32(expected);
+        Rgba32 actual = Rgba32.FromRgba32(rgba);
 
         // assert
         Assert.Equal(expected, actual);
@@ -216,13 +213,11 @@ public class Rgba32Tests
     public void Rgba32_FromBgra32_ToRgba32()
     {
         // arrange
-        var rgba = default(Rgba32);
-        var actual = default(Bgra32);
-        var expected = new Bgra32(0x1a, 0, 0x80, 0);
+        Bgra32 expected = new(0x1a, 0, 0x80, 0);
 
         // act
-        rgba.FromBgra32(expected);
-        actual.FromRgba32(rgba);
+        Rgba32 rgba = Rgba32.FromBgra32(expected);
+        Bgra32 actual = Bgra32.FromRgba32(rgba);
 
         // assert
         Assert.Equal(expected, actual);
@@ -232,13 +227,11 @@ public class Rgba32Tests
     public void Rgba32_FromAbgr32_ToRgba32()
     {
         // arrange
-        var rgba = default(Rgba32);
-        var actual = default(Abgr32);
-        var expected = new Abgr32(0x1a, 0, 0x80, 0);
+        Abgr32 expected = new(0x1a, 0, 0x80, 0);
 
         // act
-        rgba.FromAbgr32(expected);
-        actual.FromRgba32(rgba);
+        Rgba32 rgba = Rgba32.FromAbgr32(expected);
+        Abgr32 actual = Abgr32.FromRgba32(rgba);
 
         // assert
         Assert.Equal(expected, actual);
@@ -248,13 +241,11 @@ public class Rgba32Tests
     public void Rgba32_FromArgb32_ToArgb32()
     {
         // arrange
-        var rgba = default(Rgba32);
-        var actual = default(Argb32);
-        var expected = new Argb32(0x1a, 0, 0x80, 0);
+        Argb32 expected = new(0x1a, 0, 0x80, 0);
 
         // act
-        rgba.FromArgb32(expected);
-        actual.FromRgba32(rgba);
+        Rgba32 rgba = Rgba32.FromArgb32(expected);
+        Argb32 actual = Argb32.FromRgba32(rgba);
 
         // assert
         Assert.Equal(expected, actual);
@@ -264,13 +255,11 @@ public class Rgba32Tests
     public void Rgba32_FromRgb48()
     {
         // arrange
-        var input = default(Rgba32);
-        var actual = default(Rgb48);
-        var expected = new Rgb48(65535, 0, 65535);
+        Rgb48 expected = new(65535, 0, 65535);
 
         // act
-        input.FromRgb48(expected);
-        actual.FromScaledVector4(input.ToScaledVector4());
+        Rgba32 input = Rgba32.FromRgb48(expected);
+        Rgb48 actual = Rgb48.FromScaledVector4(input.ToScaledVector4());
 
         // assert
         Assert.Equal(expected, actual);
@@ -280,13 +269,11 @@ public class Rgba32Tests
     public void Rgba32_FromRgba64()
     {
         // arrange
-        var input = default(Rgba32);
-        var actual = default(Rgba64);
-        var expected = new Rgba64(65535, 0, 65535, 0);
+        Rgba64 expected = new(65535, 0, 65535, 0);
 
         // act
-        input.FromRgba64(expected);
-        actual.FromScaledVector4(input.ToScaledVector4());
+        Rgba32 input = Rgba32.FromRgba64(expected);
+        Rgba64 actual = Rgba64.FromScaledVector4(input.ToScaledVector4());
 
         // assert
         Assert.Equal(expected, actual);
@@ -296,13 +283,30 @@ public class Rgba32Tests
     public void Rgba32_FromBgra5551()
     {
         // arrange
-        var rgb = default(Rgba32);
-        uint expected = 0xFFFFFFFF;
+        const uint expected = 0xFFFFFFFF;
 
         // act
-        rgb.FromBgra5551(new Bgra5551(1.0f, 1.0f, 1.0f, 1.0f));
+        Rgba32 rgb = Rgba32.FromBgra5551(new Bgra5551(1f, 1f, 1f, 1f));
 
         // assert
         Assert.Equal(expected, rgb.PackedValue);
     }
+
+    [Fact]
+    public void Rgba32_PixelInformation()
+    {
+        PixelTypeInfo info = Rgba32.GetPixelTypeInfo();
+        Assert.Equal(Unsafe.SizeOf<Rgba32>() * 8, info.BitsPerPixel);
+        Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
+        Assert.Equal(PixelColorType.RGB | PixelColorType.Alpha, info.ColorType);
+
+        PixelComponentInfo componentInfo = info.ComponentInfo.Value;
+        Assert.Equal(4, componentInfo.ComponentCount);
+        Assert.Equal(0, componentInfo.Padding);
+        Assert.Equal(8, componentInfo.GetComponentPrecision(0));
+        Assert.Equal(8, componentInfo.GetComponentPrecision(1));
+        Assert.Equal(8, componentInfo.GetComponentPrecision(2));
+        Assert.Equal(8, componentInfo.GetComponentPrecision(3));
+        Assert.Equal(8, componentInfo.GetMaximumComponentPrecision());
+    }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/Rgba64Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Rgba64Tests.cs
index f60ed8a52..694d0ace1 100644
--- a/tests/ImageSharp.Tests/PixelFormats/Rgba64Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/Rgba64Tests.cs
@@ -2,6 +2,7 @@
 // Licensed under the Six Labors Split License.
 
 using System.Numerics;
+using System.Runtime.CompilerServices;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Tests.PixelFormats;
@@ -38,7 +39,7 @@ public class Rgba64Tests
     public void Rgba64_ToScaledVector4(ushort r, ushort g, ushort b, ushort a)
     {
         // arrange
-        var short2 = new Rgba64(r, g, b, a);
+        Rgba64 short2 = new(r, g, b, a);
 
         float max = ushort.MaxValue;
         float rr = r / max;
@@ -63,13 +64,12 @@ public class Rgba64Tests
     public void Rgba64_FromScaledVector4(ushort r, ushort g, ushort b, ushort a)
     {
         // arrange
-        var source = new Rgba64(r, g, b, a);
+        Rgba64 source = new(r, g, b, a);
 
         // act
         Vector4 scaled = source.ToScaledVector4();
 
-        Rgba64 actual = default;
-        actual.FromScaledVector4(scaled);
+        Rgba64 actual = Rgba64.FromScaledVector4(scaled);
 
         // assert
         Assert.Equal(source, actual);
@@ -78,10 +78,9 @@ public class Rgba64Tests
     [Fact]
     public void Rgba64_Clamping()
     {
-        var zero = default(Rgba64);
-        var one = default(Rgba64);
-        zero.FromVector4(Vector4.One * -1234.0f);
-        one.FromVector4(Vector4.One * 1234.0f);
+        Rgba64 zero = Rgba64.FromVector4(Vector4.One * -1234.0f);
+        Rgba64 one = Rgba64.FromVector4(Vector4.One * 1234.0f);
+
         Assert.Equal(Vector4.Zero, zero.ToVector4());
         Assert.Equal(Vector4.One, one.ToVector4());
     }
@@ -90,12 +89,11 @@ public class Rgba64Tests
     public void Rgba64_ToRgba32()
     {
         // arrange
-        var rgba64 = new Rgba64(5140, 9766, 19532, 29555);
-        var actual = default(Rgba32);
-        var expected = new Rgba32(20, 38, 76, 115);
+        Rgba64 rgba64 = new(5140, 9766, 19532, 29555);
+        Rgba32 expected = new(20, 38, 76, 115);
 
         // act
-        rgba64.ToRgba32(ref actual);
+        Rgba32 actual = rgba64.ToRgba32();
 
         // assert
         Assert.Equal(expected, actual);
@@ -105,11 +103,10 @@ public class Rgba64Tests
     public void Rgba64_FromBgra5551()
     {
         // arrange
-        var rgba = default(Rgba64);
-        ushort expected = ushort.MaxValue;
+        const ushort expected = ushort.MaxValue;
 
         // act
-        rgba.FromBgra5551(new Bgra5551(1.0f, 1.0f, 1.0f, 1.0f));
+        Rgba64 rgba = Rgba64.FromBgra5551(new Bgra5551(1.0f, 1.0f, 1.0f, 1.0f));
 
         // assert
         Assert.Equal(expected, rgba.R);
@@ -121,8 +118,8 @@ public class Rgba64Tests
     [Fact]
     public void Equality_WhenTrue()
     {
-        var c1 = new Rgba64(100, 2000, 3000, 40000);
-        var c2 = new Rgba64(100, 2000, 3000, 40000);
+        Rgba64 c1 = new(100, 2000, 3000, 40000);
+        Rgba64 c2 = new(100, 2000, 3000, 40000);
 
         Assert.True(c1.Equals(c2));
         Assert.True(c1.GetHashCode() == c2.GetHashCode());
@@ -131,9 +128,9 @@ public class Rgba64Tests
     [Fact]
     public void Equality_WhenFalse()
     {
-        var c1 = new Rgba64(100, 2000, 3000, 40000);
-        var c2 = new Rgba64(101, 2000, 3000, 40000);
-        var c3 = new Rgba64(100, 2000, 3000, 40001);
+        Rgba64 c1 = new(100, 2000, 3000, 40000);
+        Rgba64 c2 = new(101, 2000, 3000, 40000);
+        Rgba64 c3 = new(100, 2000, 3000, 40001);
 
         Assert.False(c1.Equals(c2));
         Assert.False(c2.Equals(c3));
@@ -143,11 +140,10 @@ public class Rgba64Tests
     [Fact]
     public void Rgba64_FromRgba32()
     {
-        var source = new Rgba32(20, 38, 76, 115);
-        var expected = new Rgba64(5140, 9766, 19532, 29555);
+        Rgba32 source = new(20, 38, 76, 115);
+        Rgba64 expected = new(5140, 9766, 19532, 29555);
 
-        Rgba64 actual = default;
-        actual.FromRgba32(source);
+        Rgba64 actual = Rgba64.FromRgba32(source);
 
         Assert.Equal(expected, actual);
     }
@@ -155,9 +151,9 @@ public class Rgba64Tests
     [Fact]
     public void ConstructFrom_Rgba32()
     {
-        var expected = new Rgba64(5140, 9766, 19532, 29555);
-        var source = new Rgba32(20, 38, 76, 115);
-        var actual = new Rgba64(source);
+        Rgba64 expected = new(5140, 9766, 19532, 29555);
+        Rgba32 source = new(20, 38, 76, 115);
+        Rgba64 actual = new(source);
 
         Assert.Equal(expected, actual);
     }
@@ -165,9 +161,9 @@ public class Rgba64Tests
     [Fact]
     public void ConstructFrom_Bgra32()
     {
-        var expected = new Rgba64(5140, 9766, 19532, 29555);
-        var source = new Bgra32(20, 38, 76, 115);
-        var actual = new Rgba64(source);
+        Rgba64 expected = new(5140, 9766, 19532, 29555);
+        Bgra32 source = new(20, 38, 76, 115);
+        Rgba64 actual = new(source);
 
         Assert.Equal(expected, actual);
     }
@@ -175,9 +171,9 @@ public class Rgba64Tests
     [Fact]
     public void ConstructFrom_Argb32()
     {
-        var expected = new Rgba64(5140, 9766, 19532, 29555);
-        var source = new Argb32(20, 38, 76, 115);
-        var actual = new Rgba64(source);
+        Rgba64 expected = new(5140, 9766, 19532, 29555);
+        Argb32 source = new(20, 38, 76, 115);
+        Rgba64 actual = new(source);
 
         Assert.Equal(expected, actual);
     }
@@ -185,9 +181,9 @@ public class Rgba64Tests
     [Fact]
     public void ConstructFrom_Abgr32()
     {
-        var expected = new Rgba64(5140, 9766, 19532, 29555);
-        var source = new Abgr32(20, 38, 76, 115);
-        var actual = new Rgba64(source);
+        Rgba64 expected = new(5140, 9766, 19532, 29555);
+        Abgr32 source = new(20, 38, 76, 115);
+        Rgba64 actual = new(source);
 
         Assert.Equal(expected, actual);
     }
@@ -195,9 +191,9 @@ public class Rgba64Tests
     [Fact]
     public void ConstructFrom_Rgb24()
     {
-        var expected = new Rgba64(5140, 9766, 19532, ushort.MaxValue);
-        var source = new Rgb24(20, 38, 76);
-        var actual = new Rgba64(source);
+        Rgba64 expected = new(5140, 9766, 19532, ushort.MaxValue);
+        Rgb24 source = new(20, 38, 76);
+        Rgba64 actual = new(source);
 
         Assert.Equal(expected, actual);
     }
@@ -205,9 +201,9 @@ public class Rgba64Tests
     [Fact]
     public void ConstructFrom_Bgr24()
     {
-        var expected = new Rgba64(5140, 9766, 19532, ushort.MaxValue);
-        var source = new Bgr24(20, 38, 76);
-        var actual = new Rgba64(source);
+        Rgba64 expected = new(5140, 9766, 19532, ushort.MaxValue);
+        Bgr24 source = new(20, 38, 76);
+        Rgba64 actual = new(source);
 
         Assert.Equal(expected, actual);
     }
@@ -215,11 +211,10 @@ public class Rgba64Tests
     [Fact]
     public void ConstructFrom_Vector4()
     {
-        var source = new Vector4(0f, 0.2f, 0.5f, 1f);
-        Rgba64 expected = default;
-        expected.FromScaledVector4(source);
+        Vector4 source = new(0f, 0.2f, 0.5f, 1f);
+        Rgba64 expected = Rgba64.FromScaledVector4(source);
 
-        var actual = new Rgba64(source);
+        Rgba64 actual = new(source);
 
         Assert.Equal(expected, actual);
     }
@@ -228,11 +223,11 @@ public class Rgba64Tests
     public void ToRgba32_Retval()
     {
         // arrange
-        var source = new Rgba64(5140, 9766, 19532, 29555);
-        var expected = new Rgba32(20, 38, 76, 115);
+        Rgba64 source = new(5140, 9766, 19532, 29555);
+        Rgba32 expected = new(20, 38, 76, 115);
 
         // act
-        var actual = source.ToRgba32();
+        Rgba32 actual = source.ToRgba32();
 
         // assert
         Assert.Equal(expected, actual);
@@ -242,11 +237,11 @@ public class Rgba64Tests
     public void ToBgra32_Retval()
     {
         // arrange
-        var source = new Rgba64(5140, 9766, 19532, 29555);
-        var expected = new Bgra32(20, 38, 76, 115);
+        Rgba64 source = new(5140, 9766, 19532, 29555);
+        Bgra32 expected = new(20, 38, 76, 115);
 
         // act
-        var actual = source.ToBgra32();
+        Bgra32 actual = source.ToBgra32();
 
         // assert
         Assert.Equal(expected, actual);
@@ -256,11 +251,11 @@ public class Rgba64Tests
     public void ToArgb32_Retval()
     {
         // arrange
-        var source = new Rgba64(5140, 9766, 19532, 29555);
-        var expected = new Argb32(20, 38, 76, 115);
+        Rgba64 source = new(5140, 9766, 19532, 29555);
+        Argb32 expected = new(20, 38, 76, 115);
 
         // act
-        var actual = source.ToArgb32();
+        Argb32 actual = source.ToArgb32();
 
         // assert
         Assert.Equal(expected, actual);
@@ -270,11 +265,11 @@ public class Rgba64Tests
     public void ToAbgr32_Retval()
     {
         // arrange
-        var source = new Rgba64(5140, 9766, 19532, 29555);
-        var expected = new Abgr32(20, 38, 76, 115);
+        Rgba64 source = new(5140, 9766, 19532, 29555);
+        Abgr32 expected = new(20, 38, 76, 115);
 
         // act
-        var actual = source.ToAbgr32();
+        Abgr32 actual = source.ToAbgr32();
 
         // assert
         Assert.Equal(expected, actual);
@@ -284,11 +279,11 @@ public class Rgba64Tests
     public void ToRgb24_Retval()
     {
         // arrange
-        var source = new Rgba64(5140, 9766, 19532, 29555);
-        var expected = new Rgb24(20, 38, 76);
+        Rgba64 source = new(5140, 9766, 19532, 29555);
+        Rgb24 expected = new(20, 38, 76);
 
         // act
-        var actual = source.ToRgb24();
+        Rgb24 actual = source.ToRgb24();
 
         // assert
         Assert.Equal(expected, actual);
@@ -298,13 +293,31 @@ public class Rgba64Tests
     public void ToBgr24_Retval()
     {
         // arrange
-        var source = new Rgba64(5140, 9766, 19532, 29555);
-        var expected = new Bgr24(20, 38, 76);
+        Rgba64 source = new(5140, 9766, 19532, 29555);
+        Bgr24 expected = new(20, 38, 76);
 
         // act
-        var actual = source.ToBgr24();
+        Bgr24 actual = source.ToBgr24();
 
         // assert
         Assert.Equal(expected, actual);
     }
+
+    [Fact]
+    public void Rgba64_PixelInformation()
+    {
+        PixelTypeInfo info = Rgba64.GetPixelTypeInfo();
+        Assert.Equal(Unsafe.SizeOf<Rgba64>() * 8, info.BitsPerPixel);
+        Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
+        Assert.Equal(PixelColorType.RGB | PixelColorType.Alpha, info.ColorType);
+
+        PixelComponentInfo componentInfo = info.ComponentInfo.Value;
+        Assert.Equal(4, componentInfo.ComponentCount);
+        Assert.Equal(0, componentInfo.Padding);
+        Assert.Equal(16, componentInfo.GetComponentPrecision(0));
+        Assert.Equal(16, componentInfo.GetComponentPrecision(1));
+        Assert.Equal(16, componentInfo.GetComponentPrecision(2));
+        Assert.Equal(16, componentInfo.GetComponentPrecision(3));
+        Assert.Equal(16, componentInfo.GetMaximumComponentPrecision());
+    }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/RgbaVectorTests.cs b/tests/ImageSharp.Tests/PixelFormats/RgbaVectorTests.cs
index ac6d2e3ca..5273482ef 100644
--- a/tests/ImageSharp.Tests/PixelFormats/RgbaVectorTests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/RgbaVectorTests.cs
@@ -19,12 +19,12 @@ public class RgbaVectorTests
     [Fact]
     public void AreEqual()
     {
-        var color1 = new RgbaVector(0, 0, 0F);
-        var color2 = new RgbaVector(0, 0, 0, 1F);
-        var color3 = RgbaVector.FromHex("#000");
-        var color4 = RgbaVector.FromHex("#000F");
-        var color5 = RgbaVector.FromHex("#000000");
-        var color6 = RgbaVector.FromHex("#000000FF");
+        RgbaVector color1 = new(0, 0, 0F);
+        RgbaVector color2 = new(0, 0, 0, 1F);
+        RgbaVector color3 = RgbaVector.FromHex("#000");
+        RgbaVector color4 = RgbaVector.FromHex("#000F");
+        RgbaVector color5 = RgbaVector.FromHex("#000000");
+        RgbaVector color6 = RgbaVector.FromHex("#000000FF");
 
         Assert.Equal(color1, color2);
         Assert.Equal(color1, color3);
@@ -39,11 +39,11 @@ public class RgbaVectorTests
     [Fact]
     public void AreNotEqual()
     {
-        var color1 = new RgbaVector(1, 0, 0, 1);
-        var color2 = new RgbaVector(0, 0, 0, 1);
-        var color3 = RgbaVector.FromHex("#000");
-        var color4 = RgbaVector.FromHex("#000000");
-        var color5 = RgbaVector.FromHex("#FF000000");
+        RgbaVector color1 = new(1, 0, 0, 1);
+        RgbaVector color2 = new(0, 0, 0, 1);
+        RgbaVector color3 = RgbaVector.FromHex("#000");
+        RgbaVector color4 = RgbaVector.FromHex("#000000");
+        RgbaVector color5 = RgbaVector.FromHex("#FF000000");
 
         Assert.NotEqual(color1, color2);
         Assert.NotEqual(color1, color3);
@@ -57,13 +57,13 @@ public class RgbaVectorTests
     [Fact]
     public void ConstructorAssignsProperties()
     {
-        var color1 = new RgbaVector(1, .1F, .133F, .864F);
+        RgbaVector color1 = new(1, .1F, .133F, .864F);
         Assert.Equal(1F, color1.R);
         Assert.Equal(.1F, color1.G);
         Assert.Equal(.133F, color1.B);
         Assert.Equal(.864F, color1.A);
 
-        var color2 = new RgbaVector(1, .1f, .133f);
+        RgbaVector color2 = new(1, .1f, .133f);
         Assert.Equal(1F, color2.R);
         Assert.Equal(.1F, color2.G);
         Assert.Equal(.133F, color2.B);
@@ -76,7 +76,7 @@ public class RgbaVectorTests
     [Fact]
     public void FromAndToHex()
     {
-        var color = RgbaVector.FromHex("#AABBCCDD");
+        RgbaVector color = RgbaVector.FromHex("#AABBCCDD");
         Assert.Equal(170 / 255F, color.R);
         Assert.Equal(187 / 255F, color.G);
         Assert.Equal(204 / 255F, color.B);
@@ -104,7 +104,7 @@ public class RgbaVectorTests
     [Fact]
     public void FloatLayout()
     {
-        var color = new RgbaVector(1F, 2, 3, 4);
+        RgbaVector color = new(1F, 2, 3, 4);
         Vector4 colorBase = Unsafe.As<RgbaVector, Vector4>(ref Unsafe.Add(ref color, 0));
         float[] ordered = new float[4];
         colorBase.CopyTo(ordered);
@@ -119,13 +119,11 @@ public class RgbaVectorTests
     public void RgbaVector_FromRgb48()
     {
         // arrange
-        var input = default(RgbaVector);
-        var actual = default(Rgb48);
-        var expected = new Rgb48(65535, 0, 65535);
+        Rgb48 expected = new(65535, 0, 65535);
 
         // act
-        input.FromRgb48(expected);
-        actual.FromScaledVector4(input.ToScaledVector4());
+        RgbaVector input = RgbaVector.FromRgb48(expected);
+        Rgb48 actual = Rgb48.FromScaledVector4(input.ToScaledVector4());
 
         // assert
         Assert.Equal(expected, actual);
@@ -135,13 +133,11 @@ public class RgbaVectorTests
     public void RgbaVector_FromRgba64()
     {
         // arrange
-        var input = default(RgbaVector);
-        var actual = default(Rgba64);
-        var expected = new Rgba64(65535, 0, 65535, 0);
+        Rgba64 expected = new(65535, 0, 65535, 0);
 
         // act
-        input.FromRgba64(expected);
-        actual.FromScaledVector4(input.ToScaledVector4());
+        RgbaVector input = RgbaVector.FromRgba64(expected);
+        Rgba64 actual = Rgba64.FromScaledVector4(input.ToScaledVector4());
 
         // assert
         Assert.Equal(expected, actual);
@@ -151,11 +147,10 @@ public class RgbaVectorTests
     public void RgbaVector_FromBgra5551()
     {
         // arrange
-        var rgb = default(RgbaVector);
         Vector4 expected = Vector4.One;
 
         // act
-        rgb.FromBgra5551(new Bgra5551(1.0f, 1.0f, 1.0f, 1.0f));
+        RgbaVector rgb = RgbaVector.FromBgra5551(new Bgra5551(1.0f, 1.0f, 1.0f, 1.0f));
 
         // assert
         Assert.Equal(expected, rgb.ToScaledVector4());
@@ -165,11 +160,10 @@ public class RgbaVectorTests
     public void RgbaVector_FromGrey16()
     {
         // arrange
-        var rgba = default(RgbaVector);
         Vector4 expected = Vector4.One;
 
         // act
-        rgba.FromL16(new L16(ushort.MaxValue));
+        RgbaVector rgba = RgbaVector.FromL16(new L16(ushort.MaxValue));
 
         // assert
         Assert.Equal(expected, rgba.ToScaledVector4());
@@ -179,11 +173,10 @@ public class RgbaVectorTests
     public void RgbaVector_FromGrey8()
     {
         // arrange
-        var rgba = default(RgbaVector);
         Vector4 expected = Vector4.One;
 
         // act
-        rgba.FromL8(new L8(byte.MaxValue));
+        RgbaVector rgba = RgbaVector.FromL8(new L8(byte.MaxValue));
 
         // assert
         Assert.Equal(expected, rgba.ToScaledVector4());
@@ -197,11 +190,27 @@ public class RgbaVectorTests
         using Image<RgbaVector> source = new(Configuration.Default, 1, 1, green);
         using Image<HalfVector4> clone = source.CloneAs<HalfVector4>();
 
-        Rgba32 srcColor = default;
-        Rgba32 cloneColor = default;
-        source[0, 0].ToRgba32(ref srcColor);
-        clone[0, 0].ToRgba32(ref cloneColor);
+        Rgba32 srcColor = source[0, 0].ToRgba32();
+        Rgba32 cloneColor = clone[0, 0].ToRgba32();
 
         Assert.Equal(srcColor, cloneColor);
     }
+
+    [Fact]
+    public void RgbaVector_PixelInformation()
+    {
+        PixelTypeInfo info = RgbaVector.GetPixelTypeInfo();
+        Assert.Equal(Unsafe.SizeOf<RgbaVector>() * 8, info.BitsPerPixel);
+        Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
+        Assert.Equal(PixelColorType.RGB | PixelColorType.Alpha, info.ColorType);
+
+        PixelComponentInfo componentInfo = info.ComponentInfo.Value;
+        Assert.Equal(4, componentInfo.ComponentCount);
+        Assert.Equal(0, componentInfo.Padding);
+        Assert.Equal(32, componentInfo.GetComponentPrecision(0));
+        Assert.Equal(32, componentInfo.GetComponentPrecision(1));
+        Assert.Equal(32, componentInfo.GetComponentPrecision(2));
+        Assert.Equal(32, componentInfo.GetComponentPrecision(3));
+        Assert.Equal(32, componentInfo.GetMaximumComponentPrecision());
+    }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/Short2Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Short2Tests.cs
index 8fc080d81..f23da0c7a 100644
--- a/tests/ImageSharp.Tests/PixelFormats/Short2Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/Short2Tests.cs
@@ -2,6 +2,7 @@
 // Licensed under the Six Labors Split License.
 
 using System.Numerics;
+using System.Runtime.CompilerServices;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Tests.PixelFormats;
@@ -51,7 +52,7 @@ public class Short2Tests
     public void Short2_ToScaledVector4()
     {
         // arrange
-        var short2 = new Short2(Vector2.One * 0x7FFF);
+        Short2 short2 = new(Vector2.One * 0x7FFF);
 
         // act
         Vector4 actual = short2.ToScaledVector4();
@@ -67,13 +68,12 @@ public class Short2Tests
     public void Short2_FromScaledVector4()
     {
         // arrange
-        var pixel = default(Short2);
-        var short2 = new Short2(Vector2.One * 0x7FFF);
+        Short2 short2 = new(Vector2.One * 0x7FFF);
         const ulong expected = 0x7FFF7FFF;
 
         // act
         Vector4 scaled = short2.ToScaledVector4();
-        pixel.FromScaledVector4(scaled);
+        Short2 pixel = Short2.FromScaledVector4(scaled);
         uint actual = pixel.PackedValue;
 
         // assert
@@ -84,12 +84,11 @@ public class Short2Tests
     public void Short2_ToRgba32()
     {
         // arrange
-        var short2 = new Short2(127.5f, -5.3f);
-        var actual = default(Rgba32);
-        var expected = new Rgba32(128, 127, 0, 255);
+        Short2 short2 = new(127.5f, -5.3f);
+        Rgba32 expected = new(128, 127, 0, 255);
 
         // act
-        short2.ToRgba32(ref actual);
+        Rgba32 actual = short2.ToRgba32();
 
         // assert
         Assert.Equal(expected, actual);
@@ -99,13 +98,11 @@ public class Short2Tests
     public void Short2_FromRgba32_ToRgba32()
     {
         // arrange
-        var short2 = default(Short2);
-        var actual = default(Rgba32);
-        var expected = new Rgba32(20, 38, 0, 255);
+        Rgba32 expected = new(20, 38, 0, 255);
 
         // act
-        short2.FromRgba32(expected);
-        short2.ToRgba32(ref actual);
+        Short2 short2 = Short2.FromRgba32(expected);
+        Rgba32 actual = short2.ToRgba32();
 
         // assert
         Assert.Equal(expected, actual);
@@ -115,13 +112,11 @@ public class Short2Tests
     public void Short2_FromRgb48()
     {
         // arrange
-        var input = default(Short2);
-        var actual = default(Rgb48);
-        var expected = new Rgb48(65535, 65535, 0);
+        Rgb48 expected = new(65535, 65535, 0);
 
         // act
-        input.FromRgb48(expected);
-        actual.FromScaledVector4(input.ToScaledVector4());
+        Short2 input = Short2.FromRgb48(expected);
+        Rgb48 actual = Rgb48.FromScaledVector4(input.ToScaledVector4());
 
         // assert
         Assert.Equal(expected, actual);
@@ -131,13 +126,11 @@ public class Short2Tests
     public void Short2_FromRgba64()
     {
         // arrange
-        var input = default(Short2);
-        var actual = default(Rgba64);
-        var expected = new Rgba64(65535, 65535, 0, 65535);
+        Rgba64 expected = new(65535, 65535, 0, 65535);
 
         // act
-        input.FromRgba64(expected);
-        actual.FromScaledVector4(input.ToScaledVector4());
+        Short2 input = Short2.FromRgba64(expected);
+        Rgba64 actual = Rgba64.FromScaledVector4(input.ToScaledVector4());
 
         // assert
         Assert.Equal(expected, actual);
@@ -146,11 +139,8 @@ public class Short2Tests
     [Fact]
     public void Short2_FromBgra5551()
     {
-        // arrange
-        var short2 = default(Short2);
-
         // act
-        short2.FromBgra5551(new Bgra5551(1.0f, 1.0f, 1.0f, 1.0f));
+        Short2 short2 = Short2.FromBgra5551(new Bgra5551(1.0f, 1.0f, 1.0f, 1.0f));
 
         // assert
         Vector4 actual = short2.ToScaledVector4();
@@ -159,4 +149,20 @@ public class Short2Tests
         Assert.Equal(0, actual.Z);
         Assert.Equal(1, actual.W);
     }
+
+    [Fact]
+    public void Short2_PixelInformation()
+    {
+        PixelTypeInfo info = Short2.GetPixelTypeInfo();
+        Assert.Equal(Unsafe.SizeOf<Short2>() * 8, info.BitsPerPixel);
+        Assert.Equal(PixelAlphaRepresentation.None, info.AlphaRepresentation);
+        Assert.Equal(PixelColorType.Red | PixelColorType.Green, info.ColorType);
+
+        PixelComponentInfo componentInfo = info.ComponentInfo.Value;
+        Assert.Equal(2, componentInfo.ComponentCount);
+        Assert.Equal(0, componentInfo.Padding);
+        Assert.Equal(16, componentInfo.GetComponentPrecision(0));
+        Assert.Equal(16, componentInfo.GetComponentPrecision(1));
+        Assert.Equal(16, componentInfo.GetMaximumComponentPrecision());
+    }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/Short4Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Short4Tests.cs
index c42062703..819ff0e1e 100644
--- a/tests/ImageSharp.Tests/PixelFormats/Short4Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/Short4Tests.cs
@@ -2,6 +2,7 @@
 // Licensed under the Six Labors Split License.
 
 using System.Numerics;
+using System.Runtime.CompilerServices;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Tests.PixelFormats;
@@ -12,8 +13,8 @@ public class Short4Tests
     [Fact]
     public void Short4_PackedValues()
     {
-        var shortValue1 = new Short4(11547, 12653, 29623, 193);
-        var shortValue2 = new Short4(0.1f, -0.3f, 0.5f, -0.7f);
+        Short4 shortValue1 = new(11547, 12653, 29623, 193);
+        Short4 shortValue2 = new(0.1f, -0.3f, 0.5f, -0.7f);
 
         Assert.Equal(0x00c173b7316d2d1bUL, shortValue1.PackedValue);
         Assert.Equal(18446462598732840960, shortValue2.PackedValue);
@@ -38,7 +39,7 @@ public class Short4Tests
     public void Short4_ToScaledVector4()
     {
         // arrange
-        var short4 = new Short4(Vector4.One * 0x7FFF);
+        Short4 short4 = new(Vector4.One * 0x7FFF);
 
         // act
         Vector4 actual = short4.ToScaledVector4();
@@ -54,13 +55,12 @@ public class Short4Tests
     public void Short4_FromScaledVector4()
     {
         // arrange
-        var short4 = new Short4(Vector4.One * 0x7FFF);
+        Short4 short4 = new(Vector4.One * 0x7FFF);
         Vector4 scaled = short4.ToScaledVector4();
         const long expected = 0x7FFF7FFF7FFF7FFF;
 
         // act
-        var pixel = default(Short4);
-        pixel.FromScaledVector4(scaled);
+        Short4 pixel = Short4.FromScaledVector4(scaled);
 
         // assert
         Assert.Equal((ulong)expected, pixel.PackedValue);
@@ -70,12 +70,12 @@ public class Short4Tests
     public void Short4_Clamping()
     {
         // arrange
-        var short1 = new Short4(Vector4.One * 1234567.0f);
-        var short2 = new Short4(Vector4.One * -1234567.0f);
+        Short4 short1 = new(Vector4.One * 1234567.0f);
+        Short4 short2 = new(Vector4.One * -1234567.0f);
 
         // act
-        var vector1 = short1.ToVector4();
-        var vector2 = short2.ToVector4();
+        Vector4 vector1 = short1.ToVector4();
+        Vector4 vector2 = short2.ToVector4();
 
         // assert
         Assert.Equal(Vector4.One * 0x7FFF, vector1);
@@ -86,12 +86,11 @@ public class Short4Tests
     public void Short4_ToRgba32()
     {
         // arrange
-        var shortValue = new Short4(11547, 12653, 29623, 193);
-        var actual = default(Rgba32);
-        var expected = new Rgba32(172, 177, 243, 128);
+        Short4 shortValue = new(11547, 12653, 29623, 193);
+        Rgba32 expected = new(172, 177, 243, 128);
 
         // act
-        shortValue.ToRgba32(ref actual);
+        Rgba32 actual = shortValue.ToRgba32();
 
         // assert
         Assert.Equal(expected, actual);
@@ -101,13 +100,11 @@ public class Short4Tests
     public void Short4_FromRgba32_ToRgba32()
     {
         // arrange
-        var short4 = default(Short4);
-        var actual = default(Rgba32);
-        var expected = new Rgba32(20, 38, 0, 255);
+        Rgba32 expected = new(20, 38, 0, 255);
 
         // act
-        short4.FromRgba32(expected);
-        short4.ToRgba32(ref actual);
+        Short4 short4 = Short4.FromRgba32(expected);
+        Rgba32 actual = short4.ToRgba32();
 
         // assert
         Assert.Equal(expected, actual);
@@ -117,15 +114,12 @@ public class Short4Tests
     public void Short4_FromBgra32_ToRgba32()
     {
         // arrange
-        var short4 = default(Short4);
-        var actual = default(Bgra32);
-        var expected = new Bgra32(20, 38, 0, 255);
+        Bgra32 expected = new(20, 38, 0, 255);
 
         // act
-        short4.FromBgra32(expected);
-        Rgba32 temp = default;
-        short4.ToRgba32(ref temp);
-        actual.FromRgba32(temp);
+        Short4 short4 = Short4.FromBgra32(expected);
+        Rgba32 temp = short4.ToRgba32();
+        Bgra32 actual = Bgra32.FromRgba32(temp);
 
         // assert
         Assert.Equal(expected, actual);
@@ -135,15 +129,12 @@ public class Short4Tests
     public void Short4_FromArgb32_ToRgba32()
     {
         // arrange
-        var short4 = default(Short4);
-        var actual = default(Argb32);
-        var expected = new Argb32(20, 38, 0, 255);
+        Argb32 expected = new(20, 38, 0, 255);
 
         // act
-        short4.FromArgb32(expected);
-        Rgba32 temp = default;
-        short4.ToRgba32(ref temp);
-        actual.FromRgba32(temp);
+        Short4 short4 = Short4.FromArgb32(expected);
+        Rgba32 temp = short4.ToRgba32();
+        Argb32 actual = Argb32.FromRgba32(temp);
 
         // assert
         Assert.Equal(expected, actual);
@@ -153,15 +144,12 @@ public class Short4Tests
     public void Short4_FromAbgrb32_ToRgba32()
     {
         // arrange
-        var short4 = default(Short4);
-        var actual = default(Abgr32);
-        var expected = new Abgr32(20, 38, 0, 255);
+        Abgr32 expected = new(20, 38, 0, 255);
 
         // act
-        short4.FromAbgr32(expected);
-        Rgba32 temp = default;
-        short4.ToRgba32(ref temp);
-        actual.FromRgba32(temp);
+        Short4 short4 = Short4.FromAbgr32(expected);
+        Rgba32 temp = short4.ToRgba32();
+        Abgr32 actual = Abgr32.FromRgba32(temp);
 
         // assert
         Assert.Equal(expected, actual);
@@ -171,13 +159,11 @@ public class Short4Tests
     public void Short4_FromRgb48_ToRgb48()
     {
         // arrange
-        var input = default(Short4);
-        var actual = default(Rgb48);
-        var expected = new Rgb48(65535, 0, 65535);
+        Rgb48 expected = new(65535, 0, 65535);
 
         // act
-        input.FromRgb48(expected);
-        actual.FromScaledVector4(input.ToScaledVector4());
+        Short4 input = Short4.FromRgb48(expected);
+        Rgb48 actual = Rgb48.FromScaledVector4(input.ToScaledVector4());
 
         // assert
         Assert.Equal(expected, actual);
@@ -187,13 +173,11 @@ public class Short4Tests
     public void Short4_FromRgba64_ToRgba64()
     {
         // arrange
-        var input = default(Short4);
-        var actual = default(Rgba64);
-        var expected = new Rgba64(65535, 0, 65535, 0);
+        Rgba64 expected = new(65535, 0, 65535, 0);
 
         // act
-        input.FromRgba64(expected);
-        actual.FromScaledVector4(input.ToScaledVector4());
+        Short4 input = Short4.FromRgba64(expected);
+        Rgba64 actual = Rgba64.FromScaledVector4(input.ToScaledVector4());
 
         // assert
         Assert.Equal(expected, actual);
@@ -203,13 +187,30 @@ public class Short4Tests
     public void Short4_FromBgra5551()
     {
         // arrange
-        var short4 = default(Short4);
         Vector4 expected = Vector4.One;
 
         // act
-        short4.FromBgra5551(new Bgra5551(1.0f, 1.0f, 1.0f, 1.0f));
+        Short4 short4 = Short4.FromBgra5551(new Bgra5551(1.0f, 1.0f, 1.0f, 1.0f));
 
         // assert
         Assert.Equal(expected, short4.ToScaledVector4());
     }
+
+    [Fact]
+    public void Short4_PixelInformation()
+    {
+        PixelTypeInfo info = Short4.GetPixelTypeInfo();
+        Assert.Equal(Unsafe.SizeOf<Short4>() * 8, info.BitsPerPixel);
+        Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
+        Assert.Equal(PixelColorType.RGB | PixelColorType.Alpha, info.ColorType);
+
+        PixelComponentInfo componentInfo = info.ComponentInfo.Value;
+        Assert.Equal(4, componentInfo.ComponentCount);
+        Assert.Equal(0, componentInfo.Padding);
+        Assert.Equal(16, componentInfo.GetComponentPrecision(0));
+        Assert.Equal(16, componentInfo.GetComponentPrecision(1));
+        Assert.Equal(16, componentInfo.GetComponentPrecision(2));
+        Assert.Equal(16, componentInfo.GetComponentPrecision(3));
+        Assert.Equal(16, componentInfo.GetMaximumComponentPrecision());
+    }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/UnPackedPixelTests.cs b/tests/ImageSharp.Tests/PixelFormats/UnPackedPixelTests.cs
index 5cc35b43e..651f6fe7f 100644
--- a/tests/ImageSharp.Tests/PixelFormats/UnPackedPixelTests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/UnPackedPixelTests.cs
@@ -12,8 +12,8 @@ public class UnPackedPixelTests
     [Fact]
     public void Color_Types_From_Bytes_Produce_Equal_Scaled_Component_OutPut()
     {
-        var color = new Rgba32(24, 48, 96, 192);
-        var colorVector = new RgbaVector(24 / 255F, 48 / 255F, 96 / 255F, 192 / 255F);
+        Rgba32 color = new(24, 48, 96, 192);
+        RgbaVector colorVector = new(24 / 255F, 48 / 255F, 96 / 255F, 192 / 255F);
 
         Assert.Equal(color.R, (byte)(colorVector.R * 255));
         Assert.Equal(color.G, (byte)(colorVector.G * 255));
@@ -24,8 +24,8 @@ public class UnPackedPixelTests
     [Fact]
     public void Color_Types_From_Floats_Produce_Equal_Scaled_Component_OutPut()
     {
-        var color = new Rgba32(24 / 255F, 48 / 255F, 96 / 255F, 192 / 255F);
-        var colorVector = new RgbaVector(24 / 255F, 48 / 255F, 96 / 255F, 192 / 255F);
+        Rgba32 color = new(24 / 255F, 48 / 255F, 96 / 255F, 192 / 255F);
+        RgbaVector colorVector = new(24 / 255F, 48 / 255F, 96 / 255F, 192 / 255F);
 
         Assert.Equal(color.R, (byte)(colorVector.R * 255));
         Assert.Equal(color.G, (byte)(colorVector.G * 255));
@@ -36,8 +36,8 @@ public class UnPackedPixelTests
     [Fact]
     public void Color_Types_From_Vector4_Produce_Equal_Scaled_Component_OutPut()
     {
-        var color = new Rgba32(new Vector4(24 / 255F, 48 / 255F, 96 / 255F, 192 / 255F));
-        var colorVector = new RgbaVector(24 / 255F, 48 / 255F, 96 / 255F, 192 / 255F);
+        Rgba32 color = new(new Vector4(24 / 255F, 48 / 255F, 96 / 255F, 192 / 255F));
+        RgbaVector colorVector = new(24 / 255F, 48 / 255F, 96 / 255F, 192 / 255F);
 
         Assert.Equal(color.R, (byte)(colorVector.R * 255));
         Assert.Equal(color.G, (byte)(colorVector.G * 255));
@@ -48,8 +48,8 @@ public class UnPackedPixelTests
     [Fact]
     public void Color_Types_From_Vector3_Produce_Equal_Scaled_Component_OutPut()
     {
-        var color = new Rgba32(new Vector3(24 / 255F, 48 / 255F, 96 / 255F));
-        var colorVector = new RgbaVector(24 / 255F, 48 / 255F, 96 / 255F);
+        Rgba32 color = new(new Vector3(24 / 255F, 48 / 255F, 96 / 255F));
+        RgbaVector colorVector = new(24 / 255F, 48 / 255F, 96 / 255F);
 
         Assert.Equal(color.R, (byte)(colorVector.R * 255));
         Assert.Equal(color.G, (byte)(colorVector.G * 255));
@@ -60,8 +60,8 @@ public class UnPackedPixelTests
     [Fact]
     public void Color_Types_From_Hex_Produce_Equal_Scaled_Component_OutPut()
     {
-        var color = Rgba32.ParseHex("183060C0");
-        var colorVector = RgbaVector.FromHex("183060C0");
+        Rgba32 color = Rgba32.ParseHex("183060C0");
+        RgbaVector colorVector = RgbaVector.FromHex("183060C0");
 
         Assert.Equal(color.R, (byte)(colorVector.R * 255));
         Assert.Equal(color.G, (byte)(colorVector.G * 255));
@@ -72,8 +72,8 @@ public class UnPackedPixelTests
     [Fact]
     public void Color_Types_To_Vector4_Produce_Equal_OutPut()
     {
-        var color = new Rgba32(24, 48, 96, 192);
-        var colorVector = new RgbaVector(24 / 255F, 48 / 255F, 96 / 255F, 192 / 255F);
+        Rgba32 color = new(24, 48, 96, 192);
+        RgbaVector colorVector = new(24 / 255F, 48 / 255F, 96 / 255F, 192 / 255F);
 
         Assert.Equal(color.ToVector4(), colorVector.ToVector4());
     }
@@ -81,13 +81,11 @@ public class UnPackedPixelTests
     [Fact]
     public void Color_Types_To_RgbaBytes_Produce_Equal_OutPut()
     {
-        var color = new Rgba32(24, 48, 96, 192);
-        var colorVector = new RgbaVector(24 / 255F, 48 / 255F, 96 / 255F, 192 / 255F);
+        Rgba32 color = new(24, 48, 96, 192);
+        RgbaVector colorVector = new(24 / 255F, 48 / 255F, 96 / 255F, 192 / 255F);
 
-        Rgba32 rgba = default;
-        Rgba32 rgbaVector = default;
-        color.ToRgba32(ref rgba);
-        colorVector.ToRgba32(ref rgbaVector);
+        Rgba32 rgba = color.ToRgba32();
+        Rgba32 rgbaVector = colorVector.ToRgba32();
 
         Assert.Equal(rgba, rgbaVector);
     }
@@ -95,8 +93,8 @@ public class UnPackedPixelTests
     [Fact]
     public void Color_Types_To_Hex_Produce_Equal_OutPut()
     {
-        var color = new Rgba32(24, 48, 96, 192);
-        var colorVector = new RgbaVector(24 / 255F, 48 / 255F, 96 / 255F, 192 / 255F);
+        Rgba32 color = new(24, 48, 96, 192);
+        RgbaVector colorVector = new(24 / 255F, 48 / 255F, 96 / 255F, 192 / 255F);
 
         // 183060C0
         Assert.Equal(color.ToHex(), colorVector.ToHex());
diff --git a/tests/ImageSharp.Tests/Processing/IntegralImageTests.cs b/tests/ImageSharp.Tests/Processing/IntegralImageTests.cs
index cd61d68be..81ba1693d 100644
--- a/tests/ImageSharp.Tests/Processing/IntegralImageTests.cs
+++ b/tests/ImageSharp.Tests/Processing/IntegralImageTests.cs
@@ -21,14 +21,7 @@ public class IntegralImageTests : BaseImageOperationsExtensionTest
         Buffer2D<ulong> integralBuffer = image.CalculateIntegralImage();
 
         // Assert:
-        VerifySumValues(provider, integralBuffer, (Rgba32 pixel) =>
-        {
-            L8 outputPixel = default;
-
-            outputPixel.FromRgba32(pixel);
-
-            return outputPixel.PackedValue;
-        });
+        VerifySumValues(provider, integralBuffer, (Rgba32 pixel) => L8.FromRgba32(pixel).PackedValue);
     }
 
     [Theory]
@@ -45,14 +38,7 @@ public class IntegralImageTests : BaseImageOperationsExtensionTest
         Buffer2D<ulong> integralBuffer = image.CalculateIntegralImage(interest);
 
         // Assert:
-        VerifySumValues(provider, integralBuffer, interest, (Rgba32 pixel) =>
-        {
-            L8 outputPixel = default;
-
-            outputPixel.FromRgba32(pixel);
-
-            return outputPixel.PackedValue;
-        });
+        VerifySumValues(provider, integralBuffer, interest, (Rgba32 pixel) => L8.FromRgba32(pixel).PackedValue);
     }
 
     [Theory]
@@ -88,7 +74,7 @@ public class IntegralImageTests : BaseImageOperationsExtensionTest
     private static void VerifySumValues<TPixel>(
         TestImageProvider<TPixel> provider,
         Buffer2D<ulong> integralBuffer,
-        System.Func<TPixel, ulong> getPixel)
+        Func<TPixel, ulong> getPixel)
         where TPixel : unmanaged, IPixel<TPixel>
         => VerifySumValues(provider, integralBuffer, integralBuffer.Bounds(), getPixel);
 
@@ -96,7 +82,7 @@ public class IntegralImageTests : BaseImageOperationsExtensionTest
         TestImageProvider<TPixel> provider,
         Buffer2D<ulong> integralBuffer,
         Rectangle bounds,
-        System.Func<TPixel, ulong> getPixel)
+        Func<TPixel, ulong> getPixel)
         where TPixel : unmanaged, IPixel<TPixel>
     {
         Buffer2DRegion<TPixel> image = provider.GetImage().GetRootFramePixelBuffer().GetRegion(bounds);
diff --git a/tests/ImageSharp.Tests/Processing/Processors/Transforms/AffineTransformTests.cs b/tests/ImageSharp.Tests/Processing/Processors/Transforms/AffineTransformTests.cs
index 0fc5e286d..2ed003fdd 100644
--- a/tests/ImageSharp.Tests/Processing/Processors/Transforms/AffineTransformTests.cs
+++ b/tests/ImageSharp.Tests/Processing/Processors/Transforms/AffineTransformTests.cs
@@ -21,8 +21,8 @@ public class AffineTransformTests
     /// angleDeg, sx, sy, tx, ty
     /// </summary>
     public static readonly TheoryData<float, float, float, float, float> TransformValues
-        = new TheoryData<float, float, float, float, float>
-              {
+        = new()
+        {
                   { 0, 1, 1, 0, 0 },
                   { 50, 1, 1, 0, 0 },
                   { 0, 1, 1, 20, 10 },
@@ -35,7 +35,7 @@ public class AffineTransformTests
                   { 0, 1f, 2f, 0, 0 },
               };
 
-    public static readonly TheoryData<string> ResamplerNames = new TheoryData<string>
+    public static readonly TheoryData<string> ResamplerNames = new()
     {
         nameof(KnownResamplers.Bicubic),
         nameof(KnownResamplers.Box),
@@ -55,8 +55,8 @@ public class AffineTransformTests
     };
 
     public static readonly TheoryData<string> Transform_DoesNotCreateEdgeArtifacts_ResamplerNames =
-        new TheoryData<string>
-            {
+        new()
+        {
                 nameof(KnownResamplers.NearestNeighbor),
                 nameof(KnownResamplers.Triangle),
                 nameof(KnownResamplers.Bicubic),
@@ -75,16 +75,14 @@ public class AffineTransformTests
         where TPixel : unmanaged, IPixel<TPixel>
     {
         IResampler resampler = GetResampler(resamplerName);
-        using (Image<TPixel> image = provider.GetImage())
-        {
-            AffineTransformBuilder builder = new AffineTransformBuilder()
-                .AppendRotationDegrees(30);
+        using Image<TPixel> image = provider.GetImage();
+        AffineTransformBuilder builder = new AffineTransformBuilder()
+            .AppendRotationDegrees(30);
 
-            image.Mutate(c => c.Transform(builder, resampler));
-            image.DebugSave(provider, resamplerName);
+        image.Mutate(c => c.Transform(builder, resampler));
+        image.DebugSave(provider, resamplerName);
 
-            VerifyAllPixelsAreWhiteOrTransparent(image);
-        }
+        VerifyAllPixelsAreWhiteOrTransparent(image);
     }
 
     [Theory]
@@ -98,22 +96,20 @@ public class AffineTransformTests
         float ty)
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        using (Image<TPixel> image = provider.GetImage())
-        {
-            image.DebugSave(provider, $"_original");
-            AffineTransformBuilder builder = new AffineTransformBuilder()
-                .AppendRotationDegrees(angleDeg)
-                .AppendScale(new SizeF(sx, sy))
-                .AppendTranslation(new PointF(tx, ty));
+        using Image<TPixel> image = provider.GetImage();
+        image.DebugSave(provider, $"_original");
+        AffineTransformBuilder builder = new AffineTransformBuilder()
+            .AppendRotationDegrees(angleDeg)
+            .AppendScale(new SizeF(sx, sy))
+            .AppendTranslation(new PointF(tx, ty));
 
-            this.PrintMatrix(builder.BuildMatrix(image.Size));
+        this.PrintMatrix(builder.BuildMatrix(image.Size));
 
-            image.Mutate(i => i.Transform(builder, KnownResamplers.Bicubic));
+        image.Mutate(i => i.Transform(builder, KnownResamplers.Bicubic));
 
-            FormattableString testOutputDetails = $"R({angleDeg})_S({sx},{sy})_T({tx},{ty})";
-            image.DebugSave(provider, testOutputDetails);
-            image.CompareToReferenceOutput(ValidatorComparer, provider, testOutputDetails);
-        }
+        FormattableString testOutputDetails = $"R({angleDeg})_S({sx},{sy})_T({tx},{ty})";
+        image.DebugSave(provider, testOutputDetails);
+        image.CompareToReferenceOutput(ValidatorComparer, provider, testOutputDetails);
     }
 
     [Theory]
@@ -121,23 +117,21 @@ public class AffineTransformTests
     public void Transform_RotateScale_ManuallyCentered<TPixel>(TestImageProvider<TPixel> provider, float angleDeg, float s)
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        using (Image<TPixel> image = provider.GetImage())
-        {
-            AffineTransformBuilder builder = new AffineTransformBuilder()
-                .AppendRotationDegrees(angleDeg)
-                .AppendScale(new SizeF(s, s));
+        using Image<TPixel> image = provider.GetImage();
+        AffineTransformBuilder builder = new AffineTransformBuilder()
+            .AppendRotationDegrees(angleDeg)
+            .AppendScale(new SizeF(s, s));
 
-            image.Mutate(i => i.Transform(builder, KnownResamplers.Bicubic));
+        image.Mutate(i => i.Transform(builder, KnownResamplers.Bicubic));
 
-            FormattableString testOutputDetails = $"R({angleDeg})_S({s})";
-            image.DebugSave(provider, testOutputDetails);
-            image.CompareToReferenceOutput(ValidatorComparer, provider, testOutputDetails);
-        }
+        FormattableString testOutputDetails = $"R({angleDeg})_S({s})";
+        image.DebugSave(provider, testOutputDetails);
+        image.CompareToReferenceOutput(ValidatorComparer, provider, testOutputDetails);
     }
 
     public static readonly TheoryData<int, int, int, int> Transform_IntoRectangle_Data =
-        new TheoryData<int, int, int, int>
-            {
+        new()
+        {
                 { 0, 0, 10, 10 },
                 { 0, 0, 5, 10 },
                 { 0, 0, 10, 5 },
@@ -155,19 +149,17 @@ public class AffineTransformTests
     public void Transform_FromSourceRectangle1<TPixel>(TestImageProvider<TPixel> provider)
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        var rectangle = new Rectangle(48, 0, 48, 24);
+        Rectangle rectangle = new(48, 0, 48, 24);
 
-        using (Image<TPixel> image = provider.GetImage())
-        {
-            image.DebugSave(provider, $"_original");
-            AffineTransformBuilder builder = new AffineTransformBuilder()
-                .AppendScale(new SizeF(2, 1.5F));
+        using Image<TPixel> image = provider.GetImage();
+        image.DebugSave(provider, $"_original");
+        AffineTransformBuilder builder = new AffineTransformBuilder()
+            .AppendScale(new SizeF(2, 1.5F));
 
-            image.Mutate(i => i.Transform(rectangle, builder, KnownResamplers.Spline));
+        image.Mutate(i => i.Transform(rectangle, builder, KnownResamplers.Spline));
 
-            image.DebugSave(provider);
-            image.CompareToReferenceOutput(ValidatorComparer, provider);
-        }
+        image.DebugSave(provider);
+        image.CompareToReferenceOutput(ValidatorComparer, provider);
     }
 
     [Theory]
@@ -175,18 +167,16 @@ public class AffineTransformTests
     public void Transform_FromSourceRectangle2<TPixel>(TestImageProvider<TPixel> provider)
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        var rectangle = new Rectangle(0, 24, 48, 24);
+        Rectangle rectangle = new(0, 24, 48, 24);
 
-        using (Image<TPixel> image = provider.GetImage())
-        {
-            AffineTransformBuilder builder = new AffineTransformBuilder()
-                .AppendScale(new SizeF(1F, 2F));
+        using Image<TPixel> image = provider.GetImage();
+        AffineTransformBuilder builder = new AffineTransformBuilder()
+            .AppendScale(new SizeF(1F, 2F));
 
-            image.Mutate(i => i.Transform(rectangle, builder, KnownResamplers.Spline));
+        image.Mutate(i => i.Transform(rectangle, builder, KnownResamplers.Spline));
 
-            image.DebugSave(provider);
-            image.CompareToReferenceOutput(ValidatorComparer, provider);
-        }
+        image.DebugSave(provider);
+        image.CompareToReferenceOutput(ValidatorComparer, provider);
     }
 
     [Theory]
@@ -195,17 +185,15 @@ public class AffineTransformTests
         where TPixel : unmanaged, IPixel<TPixel>
     {
         IResampler sampler = GetResampler(resamplerName);
-        using (Image<TPixel> image = provider.GetImage())
-        {
-            AffineTransformBuilder builder = new AffineTransformBuilder()
-                .AppendRotationDegrees(50)
-                .AppendScale(new SizeF(.6F, .6F));
+        using Image<TPixel> image = provider.GetImage();
+        AffineTransformBuilder builder = new AffineTransformBuilder()
+            .AppendRotationDegrees(50)
+            .AppendScale(new SizeF(.6F, .6F));
 
-            image.Mutate(i => i.Transform(builder, sampler));
+        image.Mutate(i => i.Transform(builder, sampler));
 
-            image.DebugSave(provider, resamplerName);
-            image.CompareToReferenceOutput(ValidatorComparer, provider, resamplerName);
-        }
+        image.DebugSave(provider, resamplerName);
+        image.CompareToReferenceOutput(ValidatorComparer, provider, resamplerName);
     }
 
     [Theory]
@@ -224,7 +212,7 @@ public class AffineTransformTests
     [Fact]
     public void Issue1911()
     {
-        using var image = new Image<Rgba32>(100, 100);
+        using Image<Rgba32> image = new(100, 100);
         image.Mutate(x => x = x.Transform(new Rectangle(0, 0, 99, 100), Matrix3x2.Identity, new Size(99, 100), KnownResamplers.Lanczos2));
 
         Assert.Equal(99, image.Width);
@@ -254,7 +242,7 @@ public class AffineTransformTests
     {
         using Image<TPixel> image = provider.GetImage();
 
-        var m = Matrix3x2.CreateRotation(radians, new Vector2(50, 50));
+        Matrix3x2 m = Matrix3x2.CreateRotation(radians, new Vector2(50, 50));
         Rectangle r = new(25, 25, 50, 50);
         image.Mutate(x => x.Transform(r, m, new Size(100, 100), KnownResamplers.Bicubic));
         image.DebugSave(provider, testOutputDetails: radians);
@@ -263,12 +251,8 @@ public class AffineTransformTests
 
     private static IResampler GetResampler(string name)
     {
-        PropertyInfo property = typeof(KnownResamplers).GetTypeInfo().GetProperty(name);
-
-        if (property is null)
-        {
-            throw new Exception($"No resampler named {name}");
-        }
+        PropertyInfo property = typeof(KnownResamplers).GetTypeInfo().GetProperty(name)
+                                ?? throw new InvalidOperationException($"No resampler named {name}");
 
         return (IResampler)property.GetValue(null);
     }
@@ -277,11 +261,10 @@ public class AffineTransformTests
         where TPixel : unmanaged, IPixel<TPixel>
     {
         Assert.True(image.Frames.RootFrame.DangerousTryGetSinglePixelMemory(out Memory<TPixel> data));
-        var white = new Rgb24(255, 255, 255);
+        Rgb24 white = new(255, 255, 255);
         foreach (TPixel pixel in data.Span)
         {
-            Rgba32 rgba = default;
-            pixel.ToRgba32(ref rgba);
+            Rgba32 rgba = pixel.ToRgba32();
             if (rgba.A == 0)
             {
                 continue;
diff --git a/tests/ImageSharp.Tests/Quantization/WuQuantizerTests.cs b/tests/ImageSharp.Tests/Quantization/WuQuantizerTests.cs
index d6b1f1f98..ccb79debd 100644
--- a/tests/ImageSharp.Tests/Quantization/WuQuantizerTests.cs
+++ b/tests/ImageSharp.Tests/Quantization/WuQuantizerTests.cs
@@ -14,7 +14,7 @@ public class WuQuantizerTests
         Configuration config = Configuration.Default;
         var quantizer = new WuQuantizer(new QuantizerOptions { Dither = null });
 
-        using var image = new Image<Rgba32>(config, 1, 1, Color.Black);
+        using var image = new Image<Rgba32>(config, 1, 1, Color.Black.ToPixel<Rgba32>());
         ImageFrame<Rgba32> frame = image.Frames.RootFrame;
 
         using IQuantizer<Rgba32> frameQuantizer = quantizer.CreatePixelSpecificQuantizer<Rgba32>(config);
@@ -24,7 +24,7 @@ public class WuQuantizerTests
         Assert.Equal(1, result.Width);
         Assert.Equal(1, result.Height);
 
-        Assert.Equal(Color.Black, (Color)result.Palette.Span[0]);
+        Assert.Equal(Color.Black, Color.FromPixel(result.Palette.Span[0]));
         Assert.Equal(0, result.DangerousGetRowSpan(0)[0]);
     }
 
diff --git a/tests/ImageSharp.Tests/TestFormat.cs b/tests/ImageSharp.Tests/TestFormat.cs
index f597b708d..10211f386 100644
--- a/tests/ImageSharp.Tests/TestFormat.cs
+++ b/tests/ImageSharp.Tests/TestFormat.cs
@@ -263,75 +263,49 @@ public class TestFormat : IImageFormatConfigurationModule, IImageFormat
 
     public struct TestPixelForAgnosticDecode : IPixel<TestPixelForAgnosticDecode>
     {
-        public PixelOperations<TestPixelForAgnosticDecode> CreatePixelOperations() => new();
+        public readonly Rgba32 ToRgba32() => default;
 
-        public void FromScaledVector4(Vector4 vector)
-        {
-        }
+        public readonly Vector4 ToScaledVector4() => default;
 
-        public Vector4 ToScaledVector4() => default;
+        public readonly Vector4 ToVector4() => default;
 
-        public void FromVector4(Vector4 vector)
-        {
-        }
+        public static PixelTypeInfo GetPixelTypeInfo()
+            => PixelTypeInfo.Create<TestPixelForAgnosticDecode>(
+                PixelComponentInfo.Create<TestPixelForAgnosticDecode>(2, 8, 8),
+                PixelColorType.Red | PixelColorType.Green,
+                PixelAlphaRepresentation.None);
 
-        public Vector4 ToVector4() => default;
+        public static PixelOperations<TestPixelForAgnosticDecode> CreatePixelOperations() => new();
 
-        public void FromArgb32(Argb32 source)
-        {
-        }
+        public static TestPixelForAgnosticDecode FromScaledVector4(Vector4 vector) => default;
 
-        public void FromBgra5551(Bgra5551 source)
-        {
-        }
+        public static TestPixelForAgnosticDecode FromVector4(Vector4 vector) => default;
 
-        public void FromBgr24(Bgr24 source)
-        {
-        }
+        public static TestPixelForAgnosticDecode FromAbgr32(Abgr32 source) => default;
 
-        public void FromBgra32(Bgra32 source)
-        {
-        }
+        public static TestPixelForAgnosticDecode FromArgb32(Argb32 source) => default;
 
-        public void FromAbgr32(Abgr32 source)
-        {
-        }
+        public static TestPixelForAgnosticDecode FromBgra5551(Bgra5551 source) => default;
 
-        public void FromL8(L8 source)
-        {
-        }
+        public static TestPixelForAgnosticDecode FromBgr24(Bgr24 source) => default;
 
-        public void FromL16(L16 source)
-        {
-        }
+        public static TestPixelForAgnosticDecode FromBgra32(Bgra32 source) => default;
 
-        public void FromLa16(La16 source)
-        {
-        }
+        public static TestPixelForAgnosticDecode FromL8(L8 source) => default;
 
-        public void FromLa32(La32 source)
-        {
-        }
+        public static TestPixelForAgnosticDecode FromL16(L16 source) => default;
 
-        public void FromRgb24(Rgb24 source)
-        {
-        }
+        public static TestPixelForAgnosticDecode FromLa16(La16 source) => default;
 
-        public void FromRgba32(Rgba32 source)
-        {
-        }
+        public static TestPixelForAgnosticDecode FromLa32(La32 source) => default;
 
-        public void ToRgba32(ref Rgba32 dest)
-        {
-        }
+        public static TestPixelForAgnosticDecode FromRgb24(Rgb24 source) => default;
 
-        public void FromRgb48(Rgb48 source)
-        {
-        }
+        public static TestPixelForAgnosticDecode FromRgba32(Rgba32 source) => default;
 
-        public void FromRgba64(Rgba64 source)
-        {
-        }
+        public static TestPixelForAgnosticDecode FromRgb48(Rgb48 source) => default;
+
+        public static TestPixelForAgnosticDecode FromRgba64(Rgba64 source) => default;
 
         public bool Equals(TestPixelForAgnosticDecode other) => false;
     }
diff --git a/tests/ImageSharp.Tests/TestImages.cs b/tests/ImageSharp.Tests/TestImages.cs
index 8f2192af4..9cea974a7 100644
--- a/tests/ImageSharp.Tests/TestImages.cs
+++ b/tests/ImageSharp.Tests/TestImages.cs
@@ -617,6 +617,8 @@ public static class TestImages
 
         public const string Github_RLE_legacy = "Tga/Github_RLE_legacy.tga";
         public const string WhiteStripesPattern = "Tga/whitestripes.png";
+
+        public const string Issue2629 = "Tga/issues/Issue2629.tga";
     }
 
     public static class Webp
diff --git a/tests/ImageSharp.Tests/TestUtilities/ApproximateFloatComparer.cs b/tests/ImageSharp.Tests/TestUtilities/ApproximateFloatComparer.cs
index e35f36fee..21ac6966b 100644
--- a/tests/ImageSharp.Tests/TestUtilities/ApproximateFloatComparer.cs
+++ b/tests/ImageSharp.Tests/TestUtilities/ApproximateFloatComparer.cs
@@ -4,7 +4,6 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Numerics;
 using System.Runtime.Intrinsics;
-using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Tests;
 
@@ -14,7 +13,6 @@ namespace SixLabors.ImageSharp.Tests;
 internal readonly struct ApproximateFloatComparer :
     IEqualityComparer<float>,
     IEqualityComparer<Vector2>,
-    IEqualityComparer<IPixel>,
     IEqualityComparer<Vector4>,
     IEqualityComparer<ColorMatrix>,
     IEqualityComparer<Vector256<float>>
@@ -47,13 +45,6 @@ internal readonly struct ApproximateFloatComparer :
     public int GetHashCode(Vector2 obj)
         => obj.GetHashCode();
 
-    /// <inheritdoc/>
-    public bool Equals(IPixel x, IPixel y)
-        => this.Equals(x.ToScaledVector4(), y.ToScaledVector4());
-
-    public int GetHashCode(IPixel obj)
-        => obj.ToScaledVector4().GetHashCode();
-
     /// <inheritdoc/>
     public bool Equals(Vector4 x, Vector4 y)
         => this.Equals(x.X, y.X)
diff --git a/tests/ImageSharp.Tests/TestUtilities/ImageProviders/BasicTestPatternProvider.cs b/tests/ImageSharp.Tests/TestUtilities/ImageProviders/BasicTestPatternProvider.cs
index 1e3ad3a5d..813ed505d 100644
--- a/tests/ImageSharp.Tests/TestUtilities/ImageProviders/BasicTestPatternProvider.cs
+++ b/tests/ImageSharp.Tests/TestUtilities/ImageProviders/BasicTestPatternProvider.cs
@@ -1,4 +1,4 @@
-// Copyright (c) Six Labors.
+// Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
 using System.Numerics;
@@ -8,11 +8,14 @@ namespace SixLabors.ImageSharp.Tests;
 
 public abstract partial class TestImageProvider<TPixel> : IXunitSerializable
 {
-    public virtual TPixel GetExpectedBasicTestPatternPixelAt(int x, int y)
+    [Obsolete("Called by the de-serializer; should only be called by deriving classes for de-serialization purposes")]
+    public TestImageProvider()
     {
-        throw new NotSupportedException("GetExpectedBasicTestPatternPixelAt(x,y) only works with BasicTestPattern");
     }
 
+    public virtual TPixel GetExpectedBasicTestPatternPixelAt(int x, int y)
+        => throw new NotSupportedException("GetExpectedBasicTestPatternPixelAt(x,y) only works with BasicTestPattern");
+
     private class BasicTestPatternProvider : BlankProvider
     {
         private static readonly TPixel TopLeftColor = Color.Red.ToPixel<TPixel>();
@@ -36,7 +39,7 @@ public abstract partial class TestImageProvider<TPixel> : IXunitSerializable
 
         public override Image<TPixel> GetImage()
         {
-            var result = new Image<TPixel>(this.Configuration, this.Width, this.Height);
+            Image<TPixel> result = new(this.Configuration, this.Width, this.Height);
             result.ProcessPixelRows(accessor =>
             {
                 int midY = this.Height / 2;
@@ -46,16 +49,16 @@ public abstract partial class TestImageProvider<TPixel> : IXunitSerializable
                 {
                     Span<TPixel> row = accessor.GetRowSpan(y);
 
-                    row.Slice(0, midX).Fill(TopLeftColor);
-                    row.Slice(midX, this.Width - midX).Fill(TopRightColor);
+                    row[..midX].Fill(TopLeftColor);
+                    row[midX..this.Width].Fill(TopRightColor);
                 }
 
                 for (int y = midY; y < this.Height; y++)
                 {
                     Span<TPixel> row = accessor.GetRowSpan(y);
 
-                    row.Slice(0, midX).Fill(BottomLeftColor);
-                    row.Slice(midX, this.Width - midX).Fill(BottomRightColor);
+                    row[..midX].Fill(BottomLeftColor);
+                    row[midX..this.Width].Fill(BottomRightColor);
                 }
             });
 
@@ -71,17 +74,10 @@ public abstract partial class TestImageProvider<TPixel> : IXunitSerializable
             {
                 return x < midX ? TopLeftColor : TopRightColor;
             }
-            else
-            {
-                return x < midX ? BottomLeftColor : BottomRightColor;
-            }
-        }
 
-        private static TPixel GetBottomRightColor()
-        {
-            TPixel bottomRightColor = default;
-            bottomRightColor.FromVector4(new Vector4(1f, 0f, 1f, 0.5f));
-            return bottomRightColor;
+            return x < midX ? BottomLeftColor : BottomRightColor;
         }
+
+        private static TPixel GetBottomRightColor() => TPixel.FromScaledVector4(new Vector4(1f, 0f, 1f, 0.5f));
     }
 }
diff --git a/tests/ImageSharp.Tests/TestUtilities/ImageProviders/SolidProvider.cs b/tests/ImageSharp.Tests/TestUtilities/ImageProviders/SolidProvider.cs
index 8c5101013..d78edf5bc 100644
--- a/tests/ImageSharp.Tests/TestUtilities/ImageProviders/SolidProvider.cs
+++ b/tests/ImageSharp.Tests/TestUtilities/ImageProviders/SolidProvider.cs
@@ -51,7 +51,7 @@ public abstract partial class TestImageProvider<TPixel> : IXunitSerializable
         public override Image<TPixel> GetImage()
         {
             Image<TPixel> image = base.GetImage();
-            Color color = new Rgba32(this.r, this.g, this.b, this.a);
+            Color color = Color.FromPixel(new Rgba32(this.r, this.g, this.b, this.a));
 
             image.GetRootFramePixelBuffer().FastMemoryGroup.Fill(color.ToPixel<TPixel>());
             return image;
diff --git a/tests/ImageSharp.Tests/TestUtilities/ImageProviders/TestPatternProvider.cs b/tests/ImageSharp.Tests/TestUtilities/ImageProviders/TestPatternProvider.cs
index 63307f7e2..405d048fc 100644
--- a/tests/ImageSharp.Tests/TestUtilities/ImageProviders/TestPatternProvider.cs
+++ b/tests/ImageSharp.Tests/TestUtilities/ImageProviders/TestPatternProvider.cs
@@ -1,6 +1,7 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using System.Numerics;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
 using Xunit.Abstractions;
@@ -15,19 +16,19 @@ public abstract partial class TestImageProvider<TPixel> : IXunitSerializable
     /// </summary>
     private class TestPatternProvider : BlankProvider
     {
-        private static readonly Dictionary<string, Image<TPixel>> TestImages = new Dictionary<string, Image<TPixel>>();
+        private static readonly Dictionary<string, Image<TPixel>> TestImages = [];
 
         private static readonly TPixel[] BlackWhitePixels =
-        {
-                                                                 Color.Black.ToPixel<TPixel>(),
-                                                                 Color.White.ToPixel<TPixel>()
-        };
+        [
+            Color.Black.ToPixel<TPixel>(),
+            Color.White.ToPixel<TPixel>()
+        ];
 
         private static readonly TPixel[] PinkBluePixels =
-        {
-                                                               Color.HotPink.ToPixel<TPixel>(),
-                                                               Color.Blue.ToPixel<TPixel>()
-        };
+        [
+            Color.HotPink.ToPixel<TPixel>(),
+            Color.Blue.ToPixel<TPixel>()
+        ];
 
         public TestPatternProvider(int width, int height)
             : base(width, height)
@@ -47,14 +48,15 @@ public abstract partial class TestImageProvider<TPixel> : IXunitSerializable
         {
             lock (TestImages)
             {
-                if (!TestImages.ContainsKey(this.SourceFileOrDescription))
+                if (!TestImages.TryGetValue(this.SourceFileOrDescription, out Image<TPixel> value))
                 {
-                    var image = new Image<TPixel>(this.Width, this.Height);
+                    Image<TPixel> image = new(this.Width, this.Height);
                     DrawTestPattern(image);
-                    TestImages.Add(this.SourceFileOrDescription, image);
+                    value = image;
+                    TestImages.Add(this.SourceFileOrDescription, value);
                 }
 
-                return TestImages[this.SourceFileOrDescription].Clone(this.Configuration);
+                return value.Clone(this.Configuration);
             }
         }
 
@@ -75,12 +77,13 @@ public abstract partial class TestImageProvider<TPixel> : IXunitSerializable
         /// <summary>
         /// Fills the top right quadrant with alternating solid vertical bars.
         /// </summary>
+        /// <param name="pixels">The pixel buffer.</param>
         private static void VerticalBars(Buffer2D<TPixel> pixels)
         {
             // topLeft
             int left = pixels.Width / 2;
             int right = pixels.Width;
-            int top = 0;
+            const int top = 0;
             int bottom = pixels.Height / 2;
             int stride = pixels.Width / 12;
             if (stride < 1)
@@ -96,7 +99,7 @@ public abstract partial class TestImageProvider<TPixel> : IXunitSerializable
                     if (x % stride == 0)
                     {
                         p++;
-                        p = p % PinkBluePixels.Length;
+                        p %= PinkBluePixels.Length;
                     }
 
                     pixels[x, y] = PinkBluePixels[p];
@@ -107,12 +110,13 @@ public abstract partial class TestImageProvider<TPixel> : IXunitSerializable
         /// <summary>
         /// fills the top left quadrant with a black and white checker board.
         /// </summary>
+        /// <param name="pixels">The pixel buffer.</param>
         private static void BlackWhiteChecker(Buffer2D<TPixel> pixels)
         {
             // topLeft
-            int left = 0;
+            const int left = 0;
             int right = pixels.Width / 2;
-            int top = 0;
+            const int top = 0;
             int bottom = pixels.Height / 2;
             int stride = pixels.Width / 6;
 
@@ -122,63 +126,62 @@ public abstract partial class TestImageProvider<TPixel> : IXunitSerializable
                 if (y % stride is 0)
                 {
                     p++;
-                    p = p % BlackWhitePixels.Length;
+                    p %= BlackWhitePixels.Length;
                 }
 
-                int pstart = p;
+                int pStart = p;
                 for (int x = left; x < right; x++)
                 {
                     if (x % stride is 0)
                     {
                         p++;
-                        p = p % BlackWhitePixels.Length;
+                        p %= BlackWhitePixels.Length;
                     }
 
                     pixels[x, y] = BlackWhitePixels[p];
                 }
 
-                p = pstart;
+                p = pStart;
             }
         }
 
         /// <summary>
         /// Fills the bottom left quadrant with 3 horizontal bars in Red, Green and Blue with a alpha gradient from left (transparent) to right (solid).
         /// </summary>
+        /// <param name="pixels">The pixel buffer</param>
         private static void TransparentGradients(Buffer2D<TPixel> pixels)
         {
             // topLeft
-            int left = 0;
+            const int left = 0;
             int right = pixels.Width / 2;
             int top = pixels.Height / 2;
             int bottom = pixels.Height;
             int height = (int)Math.Ceiling(pixels.Height / 6f);
 
-            var red = Color.Red.ToPixel<TPixel>().ToVector4(); // use real color so we can see how it translates in the test pattern
-            var green = Color.Green.ToPixel<TPixel>().ToVector4(); // use real color so we can see how it translates in the test pattern
-            var blue = Color.Blue.ToPixel<TPixel>().ToVector4(); // use real color so we can see how it translates in the test pattern
-
-            var c = default(TPixel);
+            Vector4 red = Color.Red.ToPixel<TPixel>().ToVector4(); // use real color so we can see how it translates in the test pattern
+            Vector4 green = Color.Green.ToPixel<TPixel>().ToVector4(); // use real color so we can see how it translates in the test pattern
+            Vector4 blue = Color.Blue.ToPixel<TPixel>().ToVector4(); // use real color so we can see how it translates in the test pattern
 
             for (int x = left; x < right; x++)
             {
-                blue.W = red.W = green.W = (float)x / (float)right;
+                blue.W = red.W = green.W = x / (float)right;
 
-                c.FromVector4(red);
+                TPixel c = TPixel.FromVector4(red);
                 int topBand = top;
                 for (int y = topBand; y < top + height; y++)
                 {
                     pixels[x, y] = c;
                 }
 
-                topBand = topBand + height;
-                c.FromVector4(green);
+                topBand += height;
+                c = TPixel.FromVector4(green);
                 for (int y = topBand; y < topBand + height; y++)
                 {
                     pixels[x, y] = c;
                 }
 
-                topBand = topBand + height;
-                c.FromVector4(blue);
+                topBand += height;
+                c = TPixel.FromVector4(blue);
                 for (int y = topBand; y < bottom; y++)
                 {
                     pixels[x, y] = c;
@@ -190,6 +193,7 @@ public abstract partial class TestImageProvider<TPixel> : IXunitSerializable
         /// Fills the bottom right quadrant with all the colors producible by converting iterating over a uint and unpacking it.
         /// A better algorithm could be used but it works
         /// </summary>
+        /// <param name="pixels">The pixel buffer.</param>
         private static void Rainbow(Buffer2D<TPixel> pixels)
         {
             int left = pixels.Width / 2;
@@ -199,19 +203,14 @@ public abstract partial class TestImageProvider<TPixel> : IXunitSerializable
 
             int pixelCount = left * top;
             uint stepsPerPixel = (uint)(uint.MaxValue / pixelCount);
-            TPixel c = default;
-            var t = new Rgba32(0);
+            Rgba32 t = default;
 
             for (int x = left; x < right; x++)
             {
                 for (int y = top; y < bottom; y++)
                 {
                     t.PackedValue += stepsPerPixel;
-                    var v = t.ToVector4();
-
-                    // v.W = (x - left) / (float)left;
-                    c.FromVector4(v);
-                    pixels[x, y] = c;
+                    pixels[x, y] = TPixel.FromRgba32(t);
                 }
             }
         }
diff --git a/tests/ImageSharp.Tests/TestUtilities/ImagingTestCaseUtility.cs b/tests/ImageSharp.Tests/TestUtilities/ImagingTestCaseUtility.cs
index 2243c852d..78e5c9020 100644
--- a/tests/ImageSharp.Tests/TestUtilities/ImagingTestCaseUtility.cs
+++ b/tests/ImageSharp.Tests/TestUtilities/ImagingTestCaseUtility.cs
@@ -1,6 +1,7 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using System.Globalization;
 using System.Reflection;
 using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.PixelFormats;
@@ -62,7 +63,7 @@ public class ImagingTestCaseUtility
             extension = ".bmp";
         }
 
-        extension = extension.ToLower();
+        extension = extension.ToLower(CultureInfo.InvariantCulture);
 
         if (extension[0] != '.')
         {
@@ -86,7 +87,7 @@ public class ImagingTestCaseUtility
             }
         }
 
-        details = details ?? string.Empty;
+        details ??= string.Empty;
         if (details != string.Empty)
         {
             details = '_' + details;
@@ -277,8 +278,7 @@ public class ImagingTestCaseUtility
     where TPixel : unmanaged, IPixel<TPixel>
     {
         TPixel pixel = img[x, y];
-        Rgba64 rgbaPixel = default;
-        rgbaPixel.FromScaledVector4(pixel.ToScaledVector4());
+        Rgba64 rgbaPixel = Rgba64.FromScaledVector4(pixel.ToScaledVector4());
         ushort change = (ushort)Math.Round((perChannelChange / 255F) * 65535F);
 
         if (rgbaPixel.R + perChannelChange <= 255)
@@ -317,7 +317,6 @@ public class ImagingTestCaseUtility
             rgbaPixel.A -= perChannelChange;
         }
 
-        pixel.FromRgba64(rgbaPixel);
-        img[x, y] = pixel;
+        img[x, y] = TPixel.FromRgba64(rgbaPixel);
     }
 }
diff --git a/tests/ImageSharp.Tests/TestUtilities/TestImageExtensions.cs b/tests/ImageSharp.Tests/TestUtilities/TestImageExtensions.cs
index 3c74b4893..5da12f264 100644
--- a/tests/ImageSharp.Tests/TestUtilities/TestImageExtensions.cs
+++ b/tests/ImageSharp.Tests/TestUtilities/TestImageExtensions.cs
@@ -692,14 +692,14 @@ public static class TestImageExtensions
         this TestImageProvider<TPixel> provider)
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        var allocator = new TestMemoryAllocator();
+        TestMemoryAllocator allocator = new();
         provider.Configuration.MemoryAllocator = allocator;
         return new AllocatorBufferCapacityConfigurator(allocator, Unsafe.SizeOf<TPixel>());
     }
 
     internal static Image<Rgba32> ToGrayscaleImage(this Buffer2D<float> buffer, float scale)
     {
-        var image = new Image<Rgba32>(buffer.Width, buffer.Height);
+        Image<Rgba32> image = new(buffer.Width, buffer.Height);
 
         Assert.True(image.Frames.RootFrame.DangerousTryGetSinglePixelMemory(out Memory<Rgba32> pixelMem));
         Span<Rgba32> pixels = pixelMem.Span;
@@ -708,8 +708,7 @@ public static class TestImageExtensions
         for (int i = 0; i < bufferSpan.Length; i++)
         {
             float value = bufferSpan[i] * scale;
-            var v = new Vector4(value, value, value, 1f);
-            pixels[i].FromVector4(v);
+            pixels[i] = Rgba32.FromVector4(new Vector4(value, value, value, 1f));
         }
 
         return image;
@@ -735,7 +734,7 @@ public static class TestImageExtensions
             Rectangle sourceRectangle = this.SourceRectangle;
             Configuration configuration = this.Configuration;
 
-            var operation = new RowOperation(configuration, sourceRectangle, source.PixelBuffer);
+            RowOperation operation = new(configuration, sourceRectangle, source.PixelBuffer);
 
             ParallelRowIterator.IterateRowIntervals<RowOperation, Vector4>(
                 configuration,
diff --git a/tests/ImageSharp.Tests/TestUtilities/TestPixel.cs b/tests/ImageSharp.Tests/TestUtilities/TestPixel.cs
index fb879c769..f0344e2b9 100644
--- a/tests/ImageSharp.Tests/TestUtilities/TestPixel.cs
+++ b/tests/ImageSharp.Tests/TestUtilities/TestPixel.cs
@@ -35,14 +35,9 @@ public class TestPixel<TPixel> : IXunitSerializable
 
     public float Alpha { get; set; }
 
-    public TPixel AsPixel()
-    {
-        var pix = default(TPixel);
-        pix.FromScaledVector4(new Vector4(this.Red, this.Green, this.Blue, this.Alpha));
-        return pix;
-    }
+    public TPixel AsPixel() => TPixel.FromScaledVector4(new Vector4(this.Red, this.Green, this.Blue, this.Alpha));
 
-    internal Span<TPixel> AsSpan() => new(new[] { this.AsPixel() });
+    internal Span<TPixel> AsSpan() => new([this.AsPixel()]);
 
     public void Deserialize(IXunitSerializationInfo info)
     {
diff --git a/tests/ImageSharp.Tests/TestUtilities/TestUtils.cs b/tests/ImageSharp.Tests/TestUtilities/TestUtils.cs
index 0b792b7fb..fbdfb9d61 100644
--- a/tests/ImageSharp.Tests/TestUtilities/TestUtils.cs
+++ b/tests/ImageSharp.Tests/TestUtilities/TestUtils.cs
@@ -19,11 +19,11 @@ namespace SixLabors.ImageSharp.Tests;
 /// </summary>
 public static class TestUtils
 {
-    private static readonly Dictionary<Type, PixelTypes> ClrTypes2PixelTypes = new Dictionary<Type, PixelTypes>();
+    private static readonly Dictionary<Type, PixelTypes> ClrTypes2PixelTypes = new();
 
     private static readonly Assembly ImageSharpAssembly = typeof(Rgba32).GetTypeInfo().Assembly;
 
-    private static readonly Dictionary<PixelTypes, Type> PixelTypes2ClrTypes = new Dictionary<PixelTypes, Type>();
+    private static readonly Dictionary<PixelTypes, Type> PixelTypes2ClrTypes = new();
 
     private static readonly PixelTypes[] AllConcretePixelTypes = GetAllPixelTypes()
         .Except(new[] { PixelTypes.Undefined, PixelTypes.All })
@@ -52,7 +52,7 @@ public static class TestUtils
 
     public static byte[] GetRandomBytes(int length, int seed = 42)
     {
-        var rnd = new Random(42);
+        Random rnd = new(seed);
         byte[] bytes = new byte[length];
         rnd.NextBytes(bytes);
         return bytes;
@@ -60,7 +60,7 @@ public static class TestUtils
 
     internal static byte[] FillImageWithRandomBytes(Image<La16> image)
     {
-        byte[] expected = TestUtils.GetRandomBytes(image.Width * image.Height * 2);
+        byte[] expected = GetRandomBytes(image.Width * image.Height * 2);
         image.ProcessPixelRows(accessor =>
         {
             int cnt = 0;
@@ -84,9 +84,6 @@ public static class TestUtils
             return false;
         }
 
-        var rgb1 = default(Rgb24);
-        var rgb2 = default(Rgb24);
-
         Buffer2D<TPixel> pixA = a.GetRootFramePixelBuffer();
         Buffer2D<TPixel> pixB = b.GetRootFramePixelBuffer();
         for (int y = 0; y < a.Height; y++)
@@ -105,11 +102,11 @@ public static class TestUtils
                 }
                 else
                 {
-                    Rgba32 rgba = default;
-                    ca.ToRgba32(ref rgba);
-                    rgb1 = rgba.Rgb;
-                    cb.ToRgba32(ref rgba);
-                    rgb2 = rgba.Rgb;
+                    Rgba32 rgba = ca.ToRgba32();
+                    Rgb24 rgb1 = rgba.Rgb;
+
+                    rgba = cb.ToRgba32();
+                    Rgb24 rgb2 = rgba.Rgb;
 
                     if (!rgb1.Equals(rgb2))
                     {
@@ -144,7 +141,7 @@ public static class TestUtils
             return PixelTypes2ClrTypes;
         }
 
-        var result = new Dictionary<PixelTypes, Type>();
+        Dictionary<PixelTypes, Type> result = new();
         foreach (PixelTypes pt in AllConcretePixelTypes)
         {
             if (pixelTypes.HasAll(pt))
@@ -167,7 +164,7 @@ public static class TestUtils
 
     internal static Color GetColorByName(string colorName)
     {
-        var f = (FieldInfo)typeof(Color).GetMember(colorName)[0];
+        FieldInfo f = (FieldInfo)typeof(Color).GetMember(colorName)[0];
         return (Color)f.GetValue(null);
     }
 
@@ -188,7 +185,7 @@ public static class TestUtils
         int width = expected.Width;
         expected.Mutate(process);
 
-        var allocator = new TestMemoryAllocator();
+        TestMemoryAllocator allocator = new();
         provider.Configuration.MemoryAllocator = allocator;
         allocator.BufferCapacityInBytes = bufferCapacityInPixelRows * width * Unsafe.SizeOf<TPixel>();
 
@@ -301,9 +298,9 @@ public static class TestUtils
         using (Image<TPixel> image0 = provider.GetImage())
         {
             Assert.True(image0.DangerousTryGetSinglePixelMemory(out Memory<TPixel> imageMem));
-            var mmg = TestMemoryManager<TPixel>.CreateAsCopyOf(imageMem.Span);
+            TestMemoryManager<TPixel> mmg = TestMemoryManager<TPixel>.CreateAsCopyOf(imageMem.Span);
 
-            using (var image1 = Image.WrapMemory(mmg.Memory, image0.Width, image0.Height))
+            using (Image<TPixel> image1 = Image.WrapMemory(mmg.Memory, image0.Width, image0.Height))
             {
                 image1.Mutate(process);
                 image1.DebugSave(
@@ -353,7 +350,7 @@ public static class TestUtils
 
         using (Image<TPixel> image = provider.GetImage())
         {
-            var bounds = new Rectangle(image.Width / 4, image.Width / 4, image.Width / 2, image.Height / 2);
+            Rectangle bounds = new(image.Width / 4, image.Width / 4, image.Width / 2, image.Height / 2);
             image.Mutate(x => process(x, bounds));
             image.DebugSave(provider, testOutputDetails, appendPixelTypeToFileName: appendPixelTypeToFileName);
             image.CompareToReferenceOutput(comparer, provider, testOutputDetails: testOutputDetails, appendPixelTypeToFileName: appendPixelTypeToFileName);
@@ -384,7 +381,7 @@ public static class TestUtils
 
         if (property is null)
         {
-            throw new Exception($"No resampler named '{name}");
+            throw new InvalidOperationException($"No resampler named '{name}");
         }
 
         return (IResampler)property.GetValue(null);
diff --git a/tests/ImageSharp.Tests/TestUtilities/Tests/TestImageProviderTests.cs b/tests/ImageSharp.Tests/TestUtilities/Tests/TestImageProviderTests.cs
index 3dceaf252..2f5291131 100644
--- a/tests/ImageSharp.Tests/TestUtilities/Tests/TestImageProviderTests.cs
+++ b/tests/ImageSharp.Tests/TestUtilities/Tests/TestImageProviderTests.cs
@@ -2,7 +2,6 @@
 // Licensed under the Six Labors Split License.
 
 using System.Collections.Concurrent;
-using SixLabors.ImageSharp.Advanced;
 using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.Metadata;
@@ -302,12 +301,11 @@ public class TestImageProviderTests
         Assert.Equal(20, img.Height);
 
         Buffer2D<TPixel> pixels = img.GetRootFramePixelBuffer();
-        Rgba32 rgba = default;
         for (int y = 0; y < pixels.Height; y++)
         {
             for (int x = 0; x < pixels.Width; x++)
             {
-                pixels[x, y].ToRgba32(ref rgba);
+                Rgba32 rgba = pixels[x, y].ToRgba32();
 
                 Assert.Equal(255, rgba.R);
                 Assert.Equal(100, rgba.G);
diff --git a/tests/ImageSharp.Tests/TestUtilities/Tests/TestUtilityExtensionsTests.cs b/tests/ImageSharp.Tests/TestUtilities/Tests/TestUtilityExtensionsTests.cs
index 33ee68068..46fb7159e 100644
--- a/tests/ImageSharp.Tests/TestUtilities/Tests/TestUtilityExtensionsTests.cs
+++ b/tests/ImageSharp.Tests/TestUtilities/Tests/TestUtilityExtensionsTests.cs
@@ -21,20 +21,17 @@ public class TestUtilityExtensionsTests
     public static Image<TPixel> CreateTestImage<TPixel>()
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        var image = new Image<TPixel>(10, 10);
+        Image<TPixel> image = new(10, 10);
 
         Buffer2D<TPixel> pixels = image.GetRootFramePixelBuffer();
         for (int i = 0; i < 10; i++)
         {
             for (int j = 0; j < 10; j++)
             {
-                var v = new Vector4(i, j, 0, 1);
+                Vector4 v = new(i, j, 0, 1);
                 v /= 10;
 
-                var color = default(TPixel);
-                color.FromVector4(v);
-
-                pixels[i, j] = color;
+                pixels[i, j] = TPixel.FromVector4(v);
             }
         }
 
diff --git a/tests/Images/External/ReferenceOutput/TgaDecoderTests/TgaDecoder_CanDecode_WhenAlphaBitsNotSet_Rgba32_32bit_no_alphabits.png b/tests/Images/External/ReferenceOutput/TgaDecoderTests/TgaDecoder_CanDecode_WhenAlphaBitsNotSet_Rgba32_32bit_no_alphabits.png
deleted file mode 100644
index e12985f7a..000000000
--- a/tests/Images/External/ReferenceOutput/TgaDecoderTests/TgaDecoder_CanDecode_WhenAlphaBitsNotSet_Rgba32_32bit_no_alphabits.png
+++ /dev/null
@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:d3dc0516f656c14b5ffcc40f88d3912f2a8fb310dfbda5836e15847e205919b5
-size 1012
diff --git a/tests/Images/External/ReferenceOutput/TgaDecoderTests/TgaDecoder_CanDecode_WhenAlphaBitsNotSet_Rgba32_32bit_rle_no_alphabits.png b/tests/Images/External/ReferenceOutput/TgaDecoderTests/TgaDecoder_CanDecode_WhenAlphaBitsNotSet_Rgba32_32bit_rle_no_alphabits.png
deleted file mode 100644
index 726721824..000000000
--- a/tests/Images/External/ReferenceOutput/TgaDecoderTests/TgaDecoder_CanDecode_WhenAlphaBitsNotSet_Rgba32_32bit_rle_no_alphabits.png
+++ /dev/null
@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:cad24c7e4657f2bc8d8a60ea76397eac0adf8dee5fc81f60bc5bc02dd7eeed8f
-size 90589
diff --git a/tests/Images/Input/Tga/32bit_no_alphabits.tga b/tests/Images/Input/Tga/32bit_no_alphabits.tga
index 903eca459..206e8d7c5 100644
--- a/tests/Images/Input/Tga/32bit_no_alphabits.tga
+++ b/tests/Images/Input/Tga/32bit_no_alphabits.tga
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:0aea1128a1bd7477dfa0d007a1eba25907be24847284c48a5f9fbd61bcea3cf0
-size 61522
+oid sha256:019315f9dcbe4516ecb15426a45c210d437e9ad152c8e1a0e80abe9449177e12
+size 235218
diff --git a/tests/Images/Input/Tga/32bit_rle_no_alphabits.tga b/tests/Images/Input/Tga/32bit_rle_no_alphabits.tga
index b21dad5e0..153b0a055 100644
--- a/tests/Images/Input/Tga/32bit_rle_no_alphabits.tga
+++ b/tests/Images/Input/Tga/32bit_rle_no_alphabits.tga
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:98a198392bd527523f8649d6126af81e5a588ad7265dc3d48a1da7b5a6cb6ff7
-size 230578
+oid sha256:33954ae93b4c7d57f52965a9028e97119c546db1da255100c2903a2760c7479e
+size 76870
diff --git a/tests/Images/Input/Tga/issues/Issue2629.tga b/tests/Images/Input/Tga/issues/Issue2629.tga
new file mode 100644
index 000000000..4c87196ad
--- /dev/null
+++ b/tests/Images/Input/Tga/issues/Issue2629.tga
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:defc1396481f426a74e8af51ed57f65cbed932f932673ce5a87fa12ea9b460f8
+size 32786