diff --git a/src/ImageSharp/Dithering/Ordered/IOrderedDither.cs b/src/ImageSharp/Dithering/Ordered/IOrderedDither.cs
index e0e11ad9e..689c9a85b 100644
--- a/src/ImageSharp/Dithering/Ordered/IOrderedDither.cs
+++ b/src/ImageSharp/Dithering/Ordered/IOrderedDither.cs
@@ -17,12 +17,12 @@ namespace SixLabors.ImageSharp.Dithering
         /// <param name="source">The source pixel</param>
         /// <param name="upper">The color to apply to the pixels above the threshold.</param>
         /// <param name="lower">The color to apply to the pixels below the threshold.</param>
-        /// <param name="bytes">The byte array to pack/unpack to. Must have a length of 4. Bytes are unpacked to Xyzw order.</param>
+        /// <param name="rgba">The <see cref="Rgba32"/> to pack/unpack to.</param>
         /// <param name="index">The component index to test the threshold against. Must range from 0 to 3.</param>
         /// <param name="x">The column index.</param>
         /// <param name="y">The row index.</param>
         /// <typeparam name="TPixel">The pixel format.</typeparam>
-        void Dither<TPixel>(ImageFrame<TPixel> image, TPixel source, TPixel upper, TPixel lower, byte[] bytes, int index, int x, int y)
+        void Dither<TPixel>(ImageFrame<TPixel> image, TPixel source, TPixel upper, TPixel lower, ref Rgba32 rgba, int index, int x, int y)
             where TPixel : struct, IPixel<TPixel>;
     }
 }
\ No newline at end of file
diff --git a/src/ImageSharp/Dithering/Ordered/OrderedDitherBase.cs b/src/ImageSharp/Dithering/Ordered/OrderedDitherBase.cs
index 09c30eb27..818a24d5d 100644
--- a/src/ImageSharp/Dithering/Ordered/OrderedDitherBase.cs
+++ b/src/ImageSharp/Dithering/Ordered/OrderedDitherBase.cs
@@ -1,13 +1,14 @@
 // Copyright (c) Six Labors and contributors.
 // Licensed under the Apache License, Version 2.0.
 
+using System;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Dithering.Base
 {
     /// <summary>
-    /// The base class for performing ordered ditheroing using a 4x4 matrix.
+    /// The base class for performing ordered dithering using a 4x4 matrix.
     /// </summary>
     public abstract class OrderedDitherBase : IOrderedDither
     {
@@ -26,14 +27,27 @@ namespace SixLabors.ImageSharp.Dithering.Base
         }
 
         /// <inheritdoc />
-        public void Dither<TPixel>(ImageFrame<TPixel> image, TPixel source, TPixel upper, TPixel lower, byte[] bytes, int index, int x, int y)
+        public void Dither<TPixel>(ImageFrame<TPixel> image, TPixel source, TPixel upper, TPixel lower, ref Rgba32 rgba, int index, int x, int y)
             where TPixel : struct, IPixel<TPixel>
         {
-            // TODO: This doesn't really cut it for me.
-            // I'd rather be using float but we need to add some sort of normalization vector methods to all IPixel implementations
-            // before we can do that as the vectors all cover different ranges.
-            source.ToXyzwBytes(bytes, 0);
-            image[x, y] = this.matrix[y % 3, x % 3] >= bytes[index] ? lower : upper;
+            source.ToRgba32(ref rgba);
+            switch (index)
+            {
+                case 0:
+                    image[x, y] = this.matrix[y % 3, x % 3] >= rgba.R ? lower : upper;
+                    return;
+                case 1:
+                    image[x, y] = this.matrix[y % 3, x % 3] >= rgba.G ? lower : upper;
+                    return;
+                case 2:
+                    image[x, y] = this.matrix[y % 3, x % 3] >= rgba.B ? lower : upper;
+                    return;
+                case 3:
+                    image[x, y] = this.matrix[y % 3, x % 3] >= rgba.A ? lower : upper;
+                    return;
+            }
+
+            throw new ArgumentOutOfRangeException(nameof(index), "Index should be between 0 and 3 inclusive.");
         }
     }
 }
\ No newline at end of file
diff --git a/src/ImageSharp/Formats/Gif/GifEncoderCore.cs b/src/ImageSharp/Formats/Gif/GifEncoderCore.cs
index 1b145a79e..41c8e944d 100644
--- a/src/ImageSharp/Formats/Gif/GifEncoderCore.cs
+++ b/src/ImageSharp/Formats/Gif/GifEncoderCore.cs
@@ -351,16 +351,16 @@ namespace SixLabors.ImageSharp.Formats.Gif
             // Get max colors for bit depth.
             int colorTableLength = (int)Math.Pow(2, this.bitDepth) * 3;
             byte[] colorTable = ArrayPool<byte>.Shared.Rent(colorTableLength);
-
+            var rgb = default(Rgb24);
             try
             {
                 for (int i = 0; i < pixelCount; i++)
                 {
                     int offset = i * 3;
-                    image.Palette[i].ToXyzBytes(this.buffer, 0);
-                    colorTable[offset] = this.buffer[0];
-                    colorTable[offset + 1] = this.buffer[1];
-                    colorTable[offset + 2] = this.buffer[2];
+                    image.Palette[i].ToRgb24(ref rgb);
+                    colorTable[offset] = rgb.R;
+                    colorTable[offset + 1] = rgb.G;
+                    colorTable[offset + 2] = rgb.B;
                 }
 
                 writer.Write(colorTable, 0, colorTableLength);
diff --git a/src/ImageSharp/Formats/Png/PngEncoderCore.cs b/src/ImageSharp/Formats/Png/PngEncoderCore.cs
index 86a63f5b4..0efd46ec7 100644
--- a/src/ImageSharp/Formats/Png/PngEncoderCore.cs
+++ b/src/ImageSharp/Formats/Png/PngEncoderCore.cs
@@ -318,6 +318,7 @@ namespace SixLabors.ImageSharp.Formats.Png
             where TPixel : struct, IPixel<TPixel>
         {
             byte[] rawScanlineArray = this.rawScanline.Array;
+            var rgba = default(Rgba32);
 
             // Copy the pixels across from the image.
             // Reuse the chunk type buffer.
@@ -326,8 +327,8 @@ namespace SixLabors.ImageSharp.Formats.Png
                 // Convert the color to YCbCr and store the luminance
                 // Optionally store the original color alpha.
                 int offset = x * this.bytesPerPixel;
-                rowSpan[x].ToXyzwBytes(this.chunkTypeBuffer, 0);
-                byte luminance = (byte)((0.299F * this.chunkTypeBuffer[0]) + (0.587F * this.chunkTypeBuffer[1]) + (0.114F * this.chunkTypeBuffer[2]));
+                rowSpan[x].ToRgba32(ref rgba);
+                byte luminance = (byte)((0.299F * rgba.R) + (0.587F * rgba.G) + (0.114F * rgba.B));
 
                 for (int i = 0; i < this.bytesPerPixel; i++)
                 {
@@ -337,7 +338,7 @@ namespace SixLabors.ImageSharp.Formats.Png
                     }
                     else
                     {
-                        rawScanlineArray[offset + i] = this.chunkTypeBuffer[3];
+                        rawScanlineArray[offset + i] = rgba.A;
                     }
                 }
             }
@@ -518,7 +519,7 @@ namespace SixLabors.ImageSharp.Formats.Png
             int colorTableLength = (int)Math.Pow(2, header.BitDepth) * 3;
             byte[] colorTable = ArrayPool<byte>.Shared.Rent(colorTableLength);
             byte[] alphaTable = ArrayPool<byte>.Shared.Rent(pixelCount);
-            byte[] bytes = ArrayPool<byte>.Shared.Rent(4);
+            var rgba = default(Rgba32);
             bool anyAlpha = false;
             try
             {
@@ -527,13 +528,13 @@ namespace SixLabors.ImageSharp.Formats.Png
                     if (quantized.Pixels.Contains(i))
                     {
                         int offset = i * 3;
-                        palette[i].ToXyzwBytes(bytes, 0);
+                        palette[i].ToRgba32(ref rgba);
 
-                        byte alpha = bytes[3];
+                        byte alpha = rgba.A;
 
-                        colorTable[offset] = bytes[0];
-                        colorTable[offset + 1] = bytes[1];
-                        colorTable[offset + 2] = bytes[2];
+                        colorTable[offset] = rgba.R;
+                        colorTable[offset + 1] = rgba.G;
+                        colorTable[offset + 2] = rgba.B;
 
                         if (alpha > this.threshold)
                         {
@@ -557,7 +558,6 @@ namespace SixLabors.ImageSharp.Formats.Png
             {
                 ArrayPool<byte>.Shared.Return(colorTable);
                 ArrayPool<byte>.Shared.Return(alphaTable);
-                ArrayPool<byte>.Shared.Return(bytes);
             }
 
             return quantized;
diff --git a/src/ImageSharp/PixelFormats/PixelConversionExtensions.cs b/src/ImageSharp/PixelFormats/PixelConversionExtensions.cs
deleted file mode 100644
index 37b225d2e..000000000
--- a/src/ImageSharp/PixelFormats/PixelConversionExtensions.cs
+++ /dev/null
@@ -1,79 +0,0 @@
-// Copyright (c) Six Labors and contributors.
-// Licensed under the Apache License, Version 2.0.
-
-using System;
-using System.Runtime.CompilerServices;
-
-namespace SixLabors.ImageSharp.PixelFormats
-{
-    /// <summary>
-    /// Extension methods for copying single pixel data into byte Spans.
-    /// TODO: This utility class exists for legacy reasons. Need to do a lot of chore work to remove it (mostly in test classes).
-    /// </summary>
-    internal static class PixelConversionExtensions
-    {
-        /// <summary>
-        /// Expands the packed representation into a given byte array.
-        /// Output is expanded to X-> Y-> Z order. Equivalent to R-> G-> B in <see cref="Rgb24"/>
-        /// </summary>
-        /// <typeparam name="TPixel">The pixel type.</typeparam>
-        /// <param name="pixel">The pixel to copy the data from.</param>
-        /// <param name="bytes">The bytes to set the color in.</param>
-        /// <param name="startIndex">The starting index of the <paramref name="bytes"/>.</param>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static void ToXyzBytes<TPixel>(this TPixel pixel, Span<byte> bytes, int startIndex)
-            where TPixel : struct, IPixel<TPixel>
-        {
-            ref Rgb24 dest = ref bytes.GetRgb24(startIndex);
-            pixel.ToRgb24(ref dest);
-        }
-
-        /// <summary>
-        /// Expands the packed representation into a given byte array.
-        /// Output is expanded to X-> Y-> Z-> W order. Equivalent to R-> G-> B-> A in <see cref="Rgba32"/>
-        /// </summary>
-        /// <typeparam name="TPixel">The pixel type.</typeparam>
-        /// <param name="pixel">The pixel to copy the data from.</param>
-        /// <param name="bytes">The bytes to set the color in.</param>
-        /// <param name="startIndex">The starting index of the <paramref name="bytes"/>.</param>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static void ToXyzwBytes<TPixel>(this TPixel pixel, Span<byte> bytes, int startIndex)
-            where TPixel : struct, IPixel<TPixel>
-        {
-            ref Rgba32 dest = ref Unsafe.As<byte, Rgba32>(ref bytes[startIndex]);
-            pixel.ToRgba32(ref dest);
-        }
-
-        /// <summary>
-        /// Expands the packed representation into a given byte array.
-        /// Output is expanded to Z-> Y-> X order. Equivalent to B-> G-> R in <see cref="Bgr24"/>
-        /// </summary>
-        /// <typeparam name="TPixel">The pixel type.</typeparam>
-        /// <param name="pixel">The pixel to copy the data from.</param>
-        /// <param name="bytes">The bytes to set the color in.</param>
-        /// <param name="startIndex">The starting index of the <paramref name="bytes"/>.</param>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static void ToZyxBytes<TPixel>(this TPixel pixel, Span<byte> bytes, int startIndex)
-            where TPixel : struct, IPixel<TPixel>
-        {
-            ref Bgr24 dest = ref Unsafe.As<byte, Bgr24>(ref bytes[startIndex]);
-            pixel.ToBgr24(ref dest);
-        }
-
-        /// <summary>
-        /// Expands the packed representation into a given byte array.
-        /// Output is expanded to Z-> Y-> X-> W order. Equivalent to B-> G-> R-> A in <see cref="Bgra32"/>
-        /// </summary>
-        /// <typeparam name="TPixel">The pixel type.</typeparam>
-        /// <param name="pixel">The pixel to copy the data from.</param>
-        /// <param name="bytes">The bytes to set the color in.</param>
-        /// <param name="startIndex">The starting index of the <paramref name="bytes"/>.</param>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static void ToZyxwBytes<TPixel>(this TPixel pixel, Span<byte> bytes, int startIndex)
-            where TPixel : struct, IPixel<TPixel>
-        {
-            ref Bgra32 dest = ref Unsafe.As<byte, Bgra32>(ref bytes[startIndex]);
-            pixel.ToBgra32(ref dest);
-        }
-    }
-}
\ No newline at end of file
diff --git a/src/ImageSharp/Processing/Processors/Binarization/OrderedDitherProcessor.cs b/src/ImageSharp/Processing/Processors/Binarization/OrderedDitherProcessor.cs
index 203a64cf1..a2fd17c94 100644
--- a/src/ImageSharp/Processing/Processors/Binarization/OrderedDitherProcessor.cs
+++ b/src/ImageSharp/Processing/Processors/Binarization/OrderedDitherProcessor.cs
@@ -77,7 +77,7 @@ namespace SixLabors.ImageSharp.Processing.Processors
             int startX = interest.X;
             int endX = interest.Right;
 
-            byte[] bytes = new byte[4];
+            var rgba = default(Rgba32);
             for (int y = startY; y < endY; y++)
             {
                 Span<TPixel> row = source.GetPixelRowSpan(y);
@@ -85,7 +85,7 @@ namespace SixLabors.ImageSharp.Processing.Processors
                 for (int x = startX; x < endX; x++)
                 {
                     TPixel sourceColor = row[x];
-                    this.Dither.Dither(source, sourceColor, this.UpperColor, this.LowerColor, bytes, this.Index, x, y);
+                    this.Dither.Dither(source, sourceColor, this.UpperColor, this.LowerColor, ref rgba, this.Index, x, y);
                 }
             }
         }
diff --git a/src/ImageSharp/Quantizers/WuQuantizer{TPixel}.cs b/src/ImageSharp/Quantizers/WuQuantizer{TPixel}.cs
index 8ab390f4e..44311e080 100644
--- a/src/ImageSharp/Quantizers/WuQuantizer{TPixel}.cs
+++ b/src/ImageSharp/Quantizers/WuQuantizer{TPixel}.cs
@@ -60,11 +60,6 @@ namespace SixLabors.ImageSharp.Quantizers
         /// </summary>
         private const int TableLength = IndexCount * IndexCount * IndexCount * IndexAlphaCount;
 
-        /// <summary>
-        /// A buffer for storing pixels
-        /// </summary>
-        private readonly byte[] rgbaBuffer = new byte[4];
-
         /// <summary>
         /// A lookup table for colors
         /// </summary>
@@ -199,19 +194,15 @@ namespace SixLabors.ImageSharp.Quantizers
         {
             // Add the color to a 3-D color histogram.
             // Colors are expected in r->g->b->a format
-            pixel.ToXyzwBytes(this.rgbaBuffer, 0);
-
-            byte r = this.rgbaBuffer[0];
-            byte g = this.rgbaBuffer[1];
-            byte b = this.rgbaBuffer[2];
-            byte a = this.rgbaBuffer[3];
+            var rgba = default(Rgba32);
+            pixel.ToRgba32(ref rgba);
 
-            int inr = r >> (8 - IndexBits);
-            int ing = g >> (8 - IndexBits);
-            int inb = b >> (8 - IndexBits);
-            int ina = a >> (8 - IndexAlphaBits);
+            int r = rgba.R >> 2; // 8 - IndexBits
+            int g = rgba.G >> 2;
+            int b = rgba.B >> 2;
+            int a = rgba.A >> 5; // 8 - IndexAlphaBits
 
-            int ind = GetPaletteIndex(inr + 1, ing + 1, inb + 1, ina + 1);
+            int ind = GetPaletteIndex(r + 1, g + 1, b + 1, a + 1);
 
             this.vwt[ind]++;
             this.vmr[ind] += r;
@@ -840,12 +831,13 @@ namespace SixLabors.ImageSharp.Quantizers
             }
 
             // Expected order r->g->b->a
-            pixel.ToXyzwBytes(this.rgbaBuffer, 0);
+            var rgba = default(Rgba32);
+            pixel.ToRgba32(ref rgba);
 
-            int r = this.rgbaBuffer[0] >> (8 - IndexBits);
-            int g = this.rgbaBuffer[1] >> (8 - IndexBits);
-            int b = this.rgbaBuffer[2] >> (8 - IndexBits);
-            int a = this.rgbaBuffer[3] >> (8 - IndexAlphaBits);
+            int r = rgba.R >> (8 - IndexBits);
+            int g = rgba.G >> (8 - IndexBits);
+            int b = rgba.B >> (8 - IndexBits);
+            int a = rgba.A >> (8 - IndexAlphaBits);
 
             return this.tag[GetPaletteIndex(r + 1, g + 1, b + 1, a + 1)];
         }
diff --git a/tests/ImageSharp.Benchmarks/Color/Bulk/ToXyz.cs b/tests/ImageSharp.Benchmarks/Color/Bulk/ToXyz.cs
index e1f5e6106..2d624c19f 100644
--- a/tests/ImageSharp.Benchmarks/Color/Bulk/ToXyz.cs
+++ b/tests/ImageSharp.Benchmarks/Color/Bulk/ToXyz.cs
@@ -35,11 +35,16 @@ namespace SixLabors.ImageSharp.Benchmarks.Color.Bulk
         {
             TPixel[] s = this.source.Array;
             byte[] d = this.destination.Array;
+            var rgb = default(Rgb24);
 
             for (int i = 0; i < this.Count; i++)
             {
                 TPixel c = s[i];
-                c.ToXyzBytes(d, i * 4);
+                int i3 = i * 3;
+                c.ToRgb24(ref rgb);
+                d[i3] = rgb.R;
+                d[i3 + 1] = rgb.G;
+                d[i3 + 2] = rgb.B;
             }
         }
 
diff --git a/tests/ImageSharp.Benchmarks/Color/Bulk/ToXyzw.cs b/tests/ImageSharp.Benchmarks/Color/Bulk/ToXyzw.cs
index 603289763..150b55aed 100644
--- a/tests/ImageSharp.Benchmarks/Color/Bulk/ToXyzw.cs
+++ b/tests/ImageSharp.Benchmarks/Color/Bulk/ToXyzw.cs
@@ -40,11 +40,17 @@ namespace SixLabors.ImageSharp.Benchmarks.Color.Bulk
         {
             TPixel[] s = this.source.Array;
             byte[] d = this.destination.Array;
+            var rgba = default(Rgba32);
 
             for (int i = 0; i < this.Count; i++)
             {
                 TPixel c = s[i];
-                c.ToXyzwBytes(d, i * 4);
+                int i4 = i * 4;
+                c.ToRgba32(ref rgba);
+                d[i4] = rgba.R;
+                d[i4 + 1] = rgba.G;
+                d[i4 + 2] = rgba.B;
+                d[i4 + 3] = rgba.A;
             }
         }
 
diff --git a/tests/ImageSharp.Tests/PixelFormats/PackedPixelTests.cs b/tests/ImageSharp.Tests/PixelFormats/PackedPixelTests.cs
index 303905baf..9b6d53fd9 100644
--- a/tests/ImageSharp.Tests/PixelFormats/PackedPixelTests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/PackedPixelTests.cs
@@ -2,7 +2,6 @@
 // Licensed under the Apache License, Version 2.0.
 
 using System;
-using System.Diagnostics;
 using System.Numerics;
 using SixLabors.ImageSharp.PixelFormats;
 using Xunit;
@@ -34,29 +33,29 @@ namespace SixLabors.ImageSharp.Tests.Colors
             Assert.Equal(26, new Alpha8(0.1F).PackedValue);
 
             // Test ordering
-            Vector4 vector = new Alpha8(.5F).ToVector4();
+            var vector = new Alpha8(.5F).ToVector4();
 
             Assert.Equal(0, vector.X);
             Assert.Equal(0, vector.Y);
             Assert.Equal(0, vector.Z);
             Assert.Equal(.5F, vector.W, 2);
 
-            byte[] rgb = new byte[3];
-            byte[] rgba = new byte[4];
-            byte[] bgr = new byte[3];
-            byte[] bgra = new byte[4];
+            var rgb = default(Rgb24);
+            var rgba = default(Rgba32);
+            var bgr = default(Bgr24);
+            var bgra = default(Bgra32);
 
-            new Alpha8(.5F).ToXyzBytes(rgb, 0);
-            Assert.Equal(rgb, new byte[] { 0, 0, 0 });
+            new Alpha8(.5F).ToRgb24(ref rgb);
+            Assert.Equal(rgb, new Rgb24(0, 0, 0));
 
-            new Alpha8(.5F).ToXyzwBytes(rgba, 0);
-            Assert.Equal(rgba, new byte[] { 0, 0, 0, 128 });
+            new Alpha8(.5F).ToRgba32(ref rgba);
+            Assert.Equal(rgba, new Rgba32(0, 0, 0, 128));
 
-            new Alpha8(.5F).ToZyxBytes(bgr, 0);
-            Assert.Equal(bgr, new byte[] { 0, 0, 0 });
+            new Alpha8(.5F).ToBgr24(ref bgr);
+            Assert.Equal(bgr, new Bgr24(0, 0, 0));
 
-            new Alpha8(.5F).ToZyxwBytes(bgra, 0);
-            Assert.Equal(bgra, new byte[] { 0, 0, 0, 128 });
+            new Alpha8(.5F).ToBgra32(ref bgra);
+            Assert.Equal(bgra, new Bgra32(0, 0, 0, 128));
         }
 
         [Fact]
@@ -82,26 +81,26 @@ namespace SixLabors.ImageSharp.Tests.Colors
             float y = -0.3f;
             float z = +0.5f;
             float w = -0.7f;
-            Argb32 argb = new Argb32(x, y, z, w);
+            var argb = new Argb32(x, y, z, w);
             Assert.Equal(0x001a0080u, argb.PackedValue);
 
             // Test ordering
-            byte[] rgb = new byte[3];
-            byte[] rgba = new byte[4];
-            byte[] bgr = new byte[3];
-            byte[] bgra = new byte[4];
+            var rgb = default(Rgb24);
+            var rgba = default(Rgba32);
+            var bgr = default(Bgr24);
+            var bgra = default(Bgra32);
 
-            argb.ToXyzBytes(rgb, 0);
-            Assert.Equal(rgb, new byte[] { 0x1a, 0, 0x80 });
+            argb.ToRgb24(ref rgb);
+            Assert.Equal(rgb, new Rgb24(0x1a, 0, 0x80));
 
-            argb.ToXyzwBytes(rgba, 0);
-            Assert.Equal(rgba, new byte[] { 0x1a, 0, 0x80, 0 });
+            argb.ToRgba32(ref rgba);
+            Assert.Equal(rgba, new Rgba32(0x1a, 0, 0x80, 0));
 
-            argb.ToZyxBytes(bgr, 0);
-            Assert.Equal(bgr, new byte[] { 0x80, 0, 0x1a });
+            argb.ToBgr24(ref bgr);
+            Assert.Equal(bgr, new Bgr24(0x1a, 0, 0x80));
 
-            argb.ToZyxwBytes(bgra, 0);
-            Assert.Equal(bgra, new byte[] { 0x80, 0, 0x1a, 0 });
+            argb.ToBgra32(ref bgra);
+            Assert.Equal(bgra, new Bgra32(0x1a, 0, 0x80, 0));
         }
 
         [Fact]
@@ -133,22 +132,22 @@ namespace SixLabors.ImageSharp.Tests.Colors
             Assert.Equal(6160, new Bgr565(x, y, z).PackedValue);
 
             // Test ordering
-            byte[] rgb = new byte[3];
-            byte[] rgba = new byte[4];
-            byte[] bgr = new byte[3];
-            byte[] bgra = new byte[4];
+            var rgb = default(Rgb24);
+            var rgba = default(Rgba32);
+            var bgr = default(Bgr24);
+            var bgra = default(Bgra32);
 
-            new Bgr565(x, y, z).ToXyzBytes(rgb, 0);
-            Assert.Equal(rgb, new byte[] { 25, 0, 132 });
+            new Bgr565(x, y, z).ToRgb24(ref rgb);
+            Assert.Equal(rgb, new Rgb24(25, 0, 132));
 
-            new Bgr565(x, y, z).ToXyzwBytes(rgba, 0);
-            Assert.Equal(rgba, new byte[] { 25, 0, 132, 255 });
+            new Bgr565(x, y, z).ToRgba32(ref rgba);
+            Assert.Equal(rgba, new Rgba32(25, 0, 132, 255));
 
-            new Bgr565(x, y, z).ToZyxBytes(bgr, 0);
-            Assert.Equal(bgr, new byte[] { 132, 0, 25 });
+            new Bgr565(x, y, z).ToBgr24(ref bgr);
+            Assert.Equal(bgr, new Bgr24(25, 0, 132));
 
-            new Bgr565(x, y, z).ToZyxwBytes(bgra, 0);
-            Assert.Equal(bgra, new byte[] { 132, 0, 25, 255 });
+            new Bgr565(x, y, z).ToBgra32(ref bgra);
+            Assert.Equal(bgra, new Bgra32(25, 0, 132, 255));
         }
 
         [Fact]
@@ -183,22 +182,22 @@ namespace SixLabors.ImageSharp.Tests.Colors
             Assert.Equal(520, new Bgra4444(x, y, z, w).PackedValue);
 
             // Test ordering
-            byte[] rgb = new byte[3];
-            byte[] rgba = new byte[4];
-            byte[] bgr = new byte[3];
-            byte[] bgra = new byte[4];
+            var rgb = default(Rgb24);
+            var rgba = default(Rgba32);
+            var bgr = default(Bgr24);
+            var bgra = default(Bgra32);
 
-            new Bgra4444(x, y, z, w).ToXyzBytes(rgb, 0);
-            Assert.Equal(rgb, new byte[] { 34, 0, 136 });
+            new Bgra4444(x, y, z, w).ToRgb24(ref rgb);
+            Assert.Equal(rgb, new Rgb24(34, 0, 136));
 
-            new Bgra4444(x, y, z, w).ToXyzwBytes(rgba, 0);
-            Assert.Equal(rgba, new byte[] { 34, 0, 136, 0 });
+            new Bgra4444(x, y, z, w).ToRgba32(ref rgba);
+            Assert.Equal(rgba, new Rgba32(34, 0, 136, 0));
 
-            new Bgra4444(x, y, z, w).ToZyxBytes(bgr, 0);
-            Assert.Equal(bgr, new byte[] { 136, 0, 34 });
+            new Bgra4444(x, y, z, w).ToBgr24(ref bgr);
+            Assert.Equal(bgr, new Bgr24(34, 0, 136));
 
-            new Bgra4444(x, y, z, w).ToZyxwBytes(bgra, 0);
-            Assert.Equal(bgra, new byte[] { 136, 0, 34, 0 });
+            new Bgra4444(x, y, z, w).ToBgra32(ref bgra);
+            Assert.Equal(bgra, new Bgra32(34, 0, 136, 0));
         }
 
         [Fact]
@@ -229,22 +228,22 @@ namespace SixLabors.ImageSharp.Tests.Colors
             Assert.Equal(3088, new Bgra5551(x, y, z, w).PackedValue);
 
             // Test ordering
-            byte[] rgb = new byte[3];
-            byte[] rgba = new byte[4];
-            byte[] bgr = new byte[3];
-            byte[] bgra = new byte[4];
+            var rgb = default(Rgb24);
+            var rgba = default(Rgba32);
+            var bgr = default(Bgr24);
+            var bgra = default(Bgra32);
 
-            new Bgra5551(x, y, z, w).ToXyzBytes(rgb, 0);
-            Assert.Equal(rgb, new byte[] { 24, 0, 131 });
+            new Bgra5551(x, y, z, w).ToRgb24(ref rgb);
+            Assert.Equal(rgb, new Rgb24(24, 0, 131));
 
-            new Bgra5551(x, y, z, w).ToXyzwBytes(rgba, 0);
-            Assert.Equal(rgba, new byte[] { 24, 0, 131, 0 });
+            new Bgra5551(x, y, z, w).ToRgba32(ref rgba);
+            Assert.Equal(rgba, new Rgba32(24, 0, 131, 0));
 
-            new Bgra5551(x, y, z, w).ToZyxBytes(bgr, 0);
-            Assert.Equal(bgr, new byte[] { 131, 0, 24 });
+            new Bgra5551(x, y, z, w).ToBgr24(ref bgr);
+            Assert.Equal(bgr, new Bgr24(24, 0, 131));
 
-            new Bgra5551(x, y, z, w).ToZyxwBytes(bgra, 0);
-            Assert.Equal(bgra, new byte[] { 131, 0, 24, 0 });
+            new Bgra5551(x, y, z, w).ToBgra32(ref bgra);
+            Assert.Equal(bgra, new Bgra32(24, 0, 131, 0));
         }
 
         [Fact]
@@ -280,27 +279,27 @@ namespace SixLabors.ImageSharp.Tests.Colors
             Assert.Equal((uint)128, new Byte4(x, y, z, w).PackedValue);
 
             // Test ordering
-            byte[] rgb = new byte[3];
-            byte[] rgba = new byte[4];
-            byte[] bgr = new byte[3];
-            byte[] bgra = new byte[4];
+            var rgb = default(Rgb24);
+            var rgba = default(Rgba32);
+            var bgr = default(Bgr24);
+            var bgra = default(Bgra32);
 
-            new Byte4(x, y, z, w).ToXyzBytes(rgb, 0);
-            Assert.Equal(rgb, new byte[] { 128, 0, 0 });
+            new Byte4(x, y, z, w).ToRgb24(ref rgb);
+            Assert.Equal(rgb, new Rgb24(128, 0, 0));
 
-            new Byte4(x, y, z, w).ToXyzwBytes(rgba, 0);
-            Assert.Equal(rgba, new byte[] { 128, 0, 0, 0 });
+            new Byte4(x, y, z, w).ToRgba32(ref rgba);
+            Assert.Equal(rgba, new Rgba32(128, 0, 0, 0));
 
-            new Byte4(x, y, z, w).ToZyxBytes(bgr, 0);
-            Assert.Equal(bgr, new byte[] { 0, 0, 128 });
+            new Byte4(x, y, z, w).ToBgr24(ref bgr);
+            Assert.Equal(bgr, new Bgr24(128, 0, 0));
 
-            new Byte4(x, y, z, w).ToZyxwBytes(bgra, 0);
-            Assert.Equal(bgra, new byte[] { 0, 0, 128, 0 });
+            new Byte4(x, y, z, w).ToBgra32(ref bgra);
+            Assert.Equal(bgra, new Bgra32(128, 0, 0, 0));
 
-            Byte4 r = new Byte4();
+            var r = new Byte4();
             r.PackFromRgba32(new Rgba32(20, 38, 0, 255));
-            r.ToXyzwBytes(rgba, 0);
-            Assert.Equal(rgba, new byte[] { 20, 38, 0, 255 });
+            r.ToRgba32(ref rgba);
+            Assert.Equal(rgba, new Rgba32(20, 38, 0, 255));
         }
 
         [Fact]
@@ -319,22 +318,22 @@ namespace SixLabors.ImageSharp.Tests.Colors
             float x = .5F;
             Assert.True(Equal(new Vector4(x, 0, 0, 1), new HalfSingle(x).ToVector4()));
 
-            byte[] rgb = new byte[3];
-            byte[] rgba = new byte[4];
-            byte[] bgr = new byte[3];
-            byte[] bgra = new byte[4];
+            var rgb = default(Rgb24);
+            var rgba = default(Rgba32);
+            var bgr = default(Bgr24);
+            var bgra = default(Bgra32);
 
-            new HalfSingle(x).ToXyzBytes(rgb, 0);
-            Assert.Equal(rgb, new byte[] { 128, 0, 0 });
+            new HalfSingle(x).ToRgb24(ref rgb);
+            Assert.Equal(rgb, new Rgb24(128, 0, 0));
 
-            new HalfSingle(x).ToXyzwBytes(rgba, 0);
-            Assert.Equal(rgba, new byte[] { 128, 0, 0, 255 });
+            new HalfSingle(x).ToRgba32(ref rgba);
+            Assert.Equal(rgba, new Rgba32(128, 0, 0, 255));
 
-            new HalfSingle(x).ToZyxBytes(bgr, 0);
-            Assert.Equal(bgr, new byte[] { 0, 0, 128 });
+            new HalfSingle(x).ToBgr24(ref bgr);
+            Assert.Equal(bgr, new Bgr24(128, 0, 0));
 
-            new HalfSingle(x).ToZyxwBytes(bgra, 0);
-            Assert.Equal(bgra, new byte[] { 0, 0, 128, 255 });
+            new HalfSingle(x).ToBgra32(ref bgra);
+            Assert.Equal(bgra, new Bgra32(128, 0, 0, 255));
         }
 
         [Fact]
@@ -356,22 +355,22 @@ namespace SixLabors.ImageSharp.Tests.Colors
             float y = .25F;
             Assert.True(Equal(new Vector4(x, y, 0, 1), new HalfVector2(x, y).ToVector4()));
 
-            byte[] rgb = new byte[3];
-            byte[] rgba = new byte[4];
-            byte[] bgr = new byte[3];
-            byte[] bgra = new byte[4];
+            var rgb = default(Rgb24);
+            var rgba = default(Rgba32);
+            var bgr = default(Bgr24);
+            var bgra = default(Bgra32);
 
-            new HalfVector2(x, y).ToXyzBytes(rgb, 0);
-            Assert.Equal(rgb, new byte[] { 128, 64, 0 });
+            new HalfVector2(x, y).ToRgb24(ref rgb);
+            Assert.Equal(rgb, new Rgb24(128, 64, 0));
 
-            new HalfVector2(x, y).ToXyzwBytes(rgba, 0);
-            Assert.Equal(rgba, new byte[] { 128, 64, 0, 255 });
+            new HalfVector2(x, y).ToRgba32(ref rgba);
+            Assert.Equal(rgba, new Rgba32(128, 64, 0, 255));
 
-            new HalfVector2(x, y).ToZyxBytes(bgr, 0);
-            Assert.Equal(bgr, new byte[] { 0, 64, 128 });
+            new HalfVector2(x, y).ToBgr24(ref bgr);
+            Assert.Equal(bgr, new Bgr24(128, 64, 0));
 
-            new HalfVector2(x, y).ToZyxwBytes(bgra, 0);
-            Assert.Equal(bgra, new byte[] { 0, 64, 128, 255 });
+            new HalfVector2(x, y).ToBgra32(ref bgra);
+            Assert.Equal(bgra, new Bgra32(128, 64, 0, 255));
         }
 
         [Fact]
@@ -402,22 +401,22 @@ namespace SixLabors.ImageSharp.Tests.Colors
             float z = .75F;
             float w = 1F;
 
-            byte[] rgb = new byte[3];
-            byte[] rgba = new byte[4];
-            byte[] bgr = new byte[3];
-            byte[] bgra = new byte[4];
+            var rgb = default(Rgb24);
+            var rgba = default(Rgba32);
+            var bgr = default(Bgr24);
+            var bgra = default(Bgra32);
 
-            new HalfVector4(x, y, z, w).ToXyzBytes(rgb, 0);
-            Assert.Equal(rgb, new byte[] { 64, 128, 191 });
+            new HalfVector4(x, y, z, w).ToRgb24(ref rgb);
+            Assert.Equal(rgb, new Rgb24(64, 128, 191));
 
-            new HalfVector4(x, y, z, w).ToXyzwBytes(rgba, 0);
-            Assert.Equal(rgba, new byte[] { 64, 128, 191, 255 });
+            new HalfVector4(x, y, z, w).ToRgba32(ref rgba);
+            Assert.Equal(rgba, new Rgba32(64, 128, 191, 255));
 
-            new HalfVector4(x, y, z, w).ToZyxBytes(bgr, 0);
-            Assert.Equal(bgr, new byte[] { 191, 128, 64 });
+            new HalfVector4(x, y, z, w).ToBgr24(ref bgr);
+            Assert.Equal(bgr, new Bgr24(64, 128, 191));
 
-            new HalfVector4(x, y, z, w).ToZyxwBytes(bgra, 0);
-            Assert.Equal(bgra, new byte[] { 191, 128, 64, 255 });
+            new HalfVector4(x, y, z, w).ToBgra32(ref bgra);
+            Assert.Equal(bgra, new Bgra32(64, 128, 191, 255));
         }
 
         [Fact]
@@ -443,26 +442,26 @@ namespace SixLabors.ImageSharp.Tests.Colors
             float x = 0.1f;
             float y = -0.3f;
             Assert.Equal(0xda0d, new NormalizedByte2(x, y).PackedValue);
-            NormalizedByte2 n = new NormalizedByte2();
+            var n = new NormalizedByte2();
             n.PackFromRgba32(new Rgba32(141, 90, 0, 0));
             Assert.Equal(0xda0d, n.PackedValue);
 
-            byte[] rgb = new byte[3];
-            byte[] rgba = new byte[4];
-            byte[] bgr = new byte[3];
-            byte[] bgra = new byte[4];
+            var rgb = default(Rgb24);
+            var rgba = default(Rgba32);
+            var bgr = default(Bgr24);
+            var bgra = default(Bgra32);
 
-            new NormalizedByte2(x, y).ToXyzBytes(rgb, 0);
-            Assert.Equal(rgb, new byte[] { 141, 90, 0 });
+            new NormalizedByte2(x, y).ToRgb24(ref rgb);
+            Assert.Equal(rgb, new Rgb24(141, 90, 0));
 
-            new NormalizedByte2(x, y).ToXyzwBytes(rgba, 0);
-            Assert.Equal(rgba, new byte[] { 141, 90, 0, 255 });
+            new NormalizedByte2(x, y).ToRgba32(ref rgba);
+            Assert.Equal(rgba, new Rgba32(141, 90, 0, 255));
 
-            new NormalizedByte2(x, y).ToZyxBytes(bgr, 0);
-            Assert.Equal(bgr, new byte[] { 0, 90, 141 });
+            new NormalizedByte2(x, y).ToBgr24(ref bgr);
+            Assert.Equal(bgr, new Bgr24(141, 90, 0));
 
-            new NormalizedByte2(x, y).ToZyxwBytes(bgra, 0);
-            Assert.Equal(bgra, new byte[] { 0, 90, 141, 255 });
+            new NormalizedByte2(x, y).ToBgra32(ref bgra);
+            Assert.Equal(bgra, new Bgra32(141, 90, 0, 255));
         }
 
         [Fact]
@@ -486,38 +485,38 @@ namespace SixLabors.ImageSharp.Tests.Colors
             float z = 0.5f;
             float w = -0.7f;
             Assert.Equal(0xA740DA0D, new NormalizedByte4(x, y, z, w).PackedValue);
-            NormalizedByte4 n = new NormalizedByte4();
+            var n = new NormalizedByte4();
             n.PackFromRgba32(new Rgba32(141, 90, 192, 39));
             Assert.Equal(0xA740DA0D, n.PackedValue);
 
             Assert.Equal((uint)958796544, new NormalizedByte4(0.0008f, 0.15f, 0.30f, 0.45f).PackedValue);
 
-            byte[] rgb = new byte[3];
-            byte[] rgba = new byte[4];
-            byte[] bgr = new byte[3];
-            byte[] bgra = new byte[4];
+            var rgb = default(Rgb24);
+            var rgba = default(Rgba32);
+            var bgr = default(Bgr24);
+            var bgra = default(Bgra32);
 
-            new NormalizedByte4(x, y, z, w).ToXyzBytes(rgb, 0);
-            Assert.Equal(rgb, new byte[] { 141, 90, 192 });
+            new NormalizedByte4(x, y, z, w).ToRgb24(ref rgb);
+            Assert.Equal(rgb, new Rgb24(141, 90, 192));
 
-            new NormalizedByte4(x, y, z, w).ToXyzwBytes(rgba, 0);
-            Assert.Equal(rgba, new byte[] { 141, 90, 192, 39 });
+            new NormalizedByte4(x, y, z, w).ToRgba32(ref rgba);
+            Assert.Equal(rgba, new Rgba32(141, 90, 192, 39));
 
-            new NormalizedByte4(x, y, z, w).ToZyxBytes(bgr, 0);
-            Assert.Equal(bgr, new byte[] { 192, 90, 141 });
+            new NormalizedByte4(x, y, z, w).ToBgr24(ref bgr);
+            Assert.Equal(bgr, new Bgr24(141, 90, 192));
 
-            new NormalizedByte4(x, y, z, w).ToZyxwBytes(bgra, 0);
-            Assert.Equal(bgra, new byte[] { 192, 90, 141, 39 });
+            new NormalizedByte4(x, y, z, w).ToBgra32(ref bgra);
+            Assert.Equal(bgra, new Bgra32(141, 90, 192, 39));
 
             // http://community.monogame.net/t/normalizedbyte4-texture2d-gives-different-results-from-xna/8012/8
-            NormalizedByte4 r = new NormalizedByte4();
+            var r = new NormalizedByte4();
             r.PackFromRgba32(new Rgba32(9, 115, 202, 127));
-            r.ToXyzwBytes(rgba, 0);
-            Assert.Equal(rgba, new byte[] { 9, 115, 202, 127 });
+            r.ToRgba32(ref rgba);
+            Assert.Equal(rgba, new Rgba32(9, 115, 202, 127));
 
             r.PackedValue = 0xff4af389;
-            r.ToXyzwBytes(rgba, 0);
-            Assert.Equal(rgba, new byte[] { 9, 115, 202, 127 });
+            r.ToRgba32(ref rgba);
+            Assert.Equal(rgba, new Rgba32(9, 115, 202, 127));
         }
 
         [Fact]
@@ -544,30 +543,30 @@ namespace SixLabors.ImageSharp.Tests.Colors
             y = -0.3f;
             Assert.Equal(3650751693, new NormalizedShort2(x, y).PackedValue);
 
-            byte[] rgb = new byte[3];
-            byte[] rgba = new byte[4];
-            byte[] bgr = new byte[3];
-            byte[] bgra = new byte[4];
+            var rgb = default(Rgb24);
+            var rgba = default(Rgba32);
+            var bgr = default(Bgr24);
+            var bgra = default(Bgra32);
 
-            NormalizedShort2 n = new NormalizedShort2();
+            var n = new NormalizedShort2();
             n.PackFromRgba32(new Rgba32(141, 90, 0, 0));
-            n.ToXyzBytes(rgb, 0);
-            Assert.Equal(rgb, new byte[] { 141, 90, 0 });
+            n.ToRgb24(ref rgb);
+            Assert.Equal(rgb, new Rgb24(141, 90, 0));
 
             // TODO: I don't think this can ever pass since the bytes are already truncated.
             // Assert.Equal(3650751693, n.PackedValue);
 
-            new NormalizedShort2(x, y).ToXyzBytes(rgb, 0);
-            Assert.Equal(rgb, new byte[] { 141, 90, 0 });
+            new NormalizedShort2(x, y).ToRgb24(ref rgb);
+            Assert.Equal(rgb, new Rgb24(141, 90, 0));
 
-            new NormalizedShort2(x, y).ToXyzwBytes(rgba, 0);
-            Assert.Equal(rgba, new byte[] { 141, 90, 0, 255 });
+            new NormalizedShort2(x, y).ToRgba32(ref rgba);
+            Assert.Equal(rgba, new Rgba32(141, 90, 0, 255));
 
-            new NormalizedShort2(x, y).ToZyxBytes(bgr, 0);
-            Assert.Equal(bgr, new byte[] { 0, 90, 141 });
+            new NormalizedShort2(x, y).ToBgr24(ref bgr);
+            Assert.Equal(bgr, new Bgr24(141, 90, 0));
 
-            new NormalizedShort2(x, y).ToZyxwBytes(bgra, 0);
-            Assert.Equal(bgra, new byte[] { 0, 90, 141, 255 });
+            new NormalizedShort2(x, y).ToBgra32(ref bgra);
+            Assert.Equal(bgra, new Bgra32(141, 90, 0, 255));
         }
 
         [Fact]
@@ -593,27 +592,27 @@ namespace SixLabors.ImageSharp.Tests.Colors
             Assert.Equal(0xa6674000d99a0ccd, new NormalizedShort4(x, y, z, w).PackedValue);
             Assert.Equal((ulong)4150390751449251866, new NormalizedShort4(0.0008f, 0.15f, 0.30f, 0.45f).PackedValue);
 
-            byte[] rgb = new byte[3];
-            byte[] rgba = new byte[4];
-            byte[] bgr = new byte[3];
-            byte[] bgra = new byte[4];
+            var rgb = default(Rgb24);
+            var rgba = default(Rgba32);
+            var bgr = default(Bgr24);
+            var bgra = default(Bgra32);
 
-            new NormalizedShort4(x, y, z, w).ToXyzBytes(rgb, 0);
-            Assert.Equal(rgb, new byte[] { 141, 90, 192 });
+            new NormalizedShort4(x, y, z, w).ToRgb24(ref rgb);
+            Assert.Equal(rgb, new Rgb24(141, 90, 192));
 
-            new NormalizedShort4(x, y, z, w).ToXyzwBytes(rgba, 0);
-            Assert.Equal(rgba, new byte[] { 141, 90, 192, 39 });
+            new NormalizedShort4(x, y, z, w).ToRgba32(ref rgba);
+            Assert.Equal(rgba, new Rgba32(141, 90, 192, 39));
 
-            new NormalizedShort4(x, y, z, w).ToZyxBytes(bgr, 0);
-            Assert.Equal(bgr, new byte[] { 192, 90, 141 });
+            new NormalizedShort4(x, y, z, w).ToBgr24(ref bgr);
+            Assert.Equal(bgr, new Bgr24(141, 90, 192));
 
-            new NormalizedShort4(x, y, z, w).ToZyxwBytes(bgra, 0);
-            Assert.Equal(bgra, new byte[] { 192, 90, 141, 39 });
+            new NormalizedShort4(x, y, z, w).ToBgra32(ref bgra);
+            Assert.Equal(bgra, new Bgra32(141, 90, 192, 39));
 
-            NormalizedShort4 r = new NormalizedShort4();
+            var r = new NormalizedShort4();
             r.PackFromRgba32(new Rgba32(9, 115, 202, 127));
-            r.ToXyzwBytes(rgba, 0);
-            Assert.Equal(rgba, new byte[] { 9, 115, 202, 127 });
+            r.ToRgba32(ref rgba);
+            Assert.Equal(rgba, new Rgba32(9, 115, 202, 127));
         }
 
         [Fact]
@@ -640,22 +639,22 @@ namespace SixLabors.ImageSharp.Tests.Colors
             Assert.Equal((uint)6554, new Rg32(x, y).PackedValue);
 
             // Test ordering
-            byte[] rgb = new byte[3];
-            byte[] rgba = new byte[4];
-            byte[] bgr = new byte[3];
-            byte[] bgra = new byte[4];
+            var rgb = default(Rgb24);
+            var rgba = default(Rgba32);
+            var bgr = default(Bgr24);
+            var bgra = default(Bgra32);
 
-            new Rg32(x, y).ToXyzBytes(rgb, 0);
-            Assert.Equal(rgb, new byte[] { 25, 0, 0 });
+            new Rg32(x, y).ToRgb24(ref rgb);
+            Assert.Equal(rgb, new Rgb24(25, 0, 0));
 
-            new Rg32(x, y).ToXyzwBytes(rgba, 0);
-            Assert.Equal(rgba, new byte[] { 25, 0, 0, 255 });
+            new Rg32(x, y).ToRgba32(ref rgba);
+            Assert.Equal(rgba, new Rgba32(25, 0, 0, 255));
 
-            new Rg32(x, y).ToZyxBytes(bgr, 0);
-            Assert.Equal(bgr, new byte[] { 0, 0, 25 });
+            new Rg32(x, y).ToBgr24(ref bgr);
+            Assert.Equal(bgr, new Bgr24(25, 0, 0));
 
-            new Rg32(x, y).ToZyxwBytes(bgra, 0);
-            Assert.Equal(bgra, new byte[] { 0, 0, 25, 255 });
+            new Rg32(x, y).ToBgra32(ref bgra);
+            Assert.Equal(bgra, new Bgra32(25, 0, 0, 255));
         }
 
         [Fact]
@@ -685,28 +684,28 @@ namespace SixLabors.ImageSharp.Tests.Colors
             w = -0.7f;
             Assert.Equal((uint)536871014, new Rgba1010102(x, y, z, w).PackedValue);
 
-            byte[] rgb = new byte[3];
-            byte[] rgba = new byte[4];
-            byte[] bgr = new byte[3];
-            byte[] bgra = new byte[4];
+            var rgb = default(Rgb24);
+            var rgba = default(Rgba32);
+            var bgr = default(Bgr24);
+            var bgra = default(Bgra32);
 
-            new Rgba1010102(x, y, z, w).ToXyzBytes(rgb, 0);
-            Assert.Equal(rgb, new byte[] { 25, 0, 128 });
+            new Rgba1010102(x, y, z, w).ToRgb24(ref rgb);
+            Assert.Equal(rgb, new Rgb24(25, 0, 128));
 
-            new Rgba1010102(x, y, z, w).ToXyzwBytes(rgba, 0);
-            Assert.Equal(rgba, new byte[] { 25, 0, 128, 0 });
+            new Rgba1010102(x, y, z, w).ToRgba32(ref rgba);
+            Assert.Equal(rgba, new Rgba32(25, 0, 128, 0));
 
-            new Rgba1010102(x, y, z, w).ToZyxBytes(bgr, 0);
-            Assert.Equal(bgr, new byte[] { 128, 0, 25 });
+            new Rgba1010102(x, y, z, w).ToBgr24(ref bgr);
+            Assert.Equal(bgr, new Bgr24(25, 0, 128));
 
-            new Rgba1010102(x, y, z, w).ToZyxwBytes(bgra, 0);
-            Assert.Equal(bgra, new byte[] { 128, 0, 25, 0 });
+            new Rgba1010102(x, y, z, w).ToBgra32(ref bgra);
+            Assert.Equal(bgra, new Bgra32(25, 0, 128, 0));
 
             // Alpha component accuracy will be awful.
-            Rgba1010102 r = new Rgba1010102();
+            var r = new Rgba1010102();
             r.PackFromRgba32(new Rgba32(25, 0, 128, 0));
-            r.ToXyzwBytes(rgba, 0);
-            Assert.Equal(rgba, new byte[] { 25, 0, 128, 0 });
+            r.ToRgba32(ref rgba);
+            Assert.Equal(rgba, new Rgba32(25, 0, 128, 0));
         }
 
         [Fact]
@@ -732,26 +731,26 @@ namespace SixLabors.ImageSharp.Tests.Colors
             float y = -0.3f;
             float z = +0.5f;
             float w = -0.7f;
-            Rgba32 rgba32 = new Rgba32(x, y, z, w);
+            var rgba32 = new Rgba32(x, y, z, w);
             Assert.Equal(0x80001Au, rgba32.PackedValue);
 
             // Test ordering
-            byte[] rgb = new byte[3];
-            byte[] rgba = new byte[4];
-            byte[] bgr = new byte[3];
-            byte[] bgra = new byte[4];
+            var rgb = default(Rgb24);
+            var rgba = default(Rgba32);
+            var bgr = default(Bgr24);
+            var bgra = default(Bgra32);
 
-            rgba32.ToXyzBytes(rgb, 0);
-            Assert.Equal(rgb, new byte[] { 0x1a, 0, 0x80 });
+            rgba32.ToRgb24(ref rgb);
+            Assert.Equal(rgb, new Rgb24(0x1a, 0, 0x80));
 
-            rgba32.ToXyzwBytes(rgba, 0);
-            Assert.Equal(rgba, new byte[] { 0x1a, 0, 0x80, 0 });
+            rgba32.ToRgba32(ref rgba);
+            Assert.Equal(rgba, new Rgba32(0x1a, 0, 0x80, 0));
 
-            rgba32.ToZyxBytes(bgr, 0);
-            Assert.Equal(bgr, new byte[] { 0x80, 0, 0x1a });
+            rgba32.ToBgr24(ref bgr);
+            Assert.Equal(bgr, new Bgr24(0x1a, 0, 0x80));
 
-            rgba32.ToZyxwBytes(bgra, 0);
-            Assert.Equal(bgra, new byte[] { 0x80, 0, 0x1a, 0 });
+            rgba32.ToBgra32(ref bgra);
+            Assert.Equal(bgra, new Bgra32(0x1a, 0, 0x80, 0));
         }
 
         [Fact]
@@ -779,27 +778,27 @@ namespace SixLabors.ImageSharp.Tests.Colors
             float w = 0.45f;
             Assert.Equal((ulong)0x73334CCC2666147B, new Rgba64(x, y, z, w).PackedValue);
 
-            byte[] rgb = new byte[3];
-            byte[] rgba = new byte[4];
-            byte[] bgr = new byte[3];
-            byte[] bgra = new byte[4];
+            var rgb = default(Rgb24);
+            var rgba = default(Rgba32);
+            var bgr = default(Bgr24);
+            var bgra = default(Bgra32);
 
-            new Rgba64(x, y, z, w).ToXyzBytes(rgb, 0);
-            Assert.Equal(rgb, new byte[] { 20, 38, 76 });
+            new Rgba64(x, y, z, w).ToRgb24(ref rgb);
+            Assert.Equal(rgb, new Rgb24(20, 38, 76));
 
-            new Rgba64(x, y, z, w).ToXyzwBytes(rgba, 0);
-            Assert.Equal(rgba, new byte[] { 20, 38, 76, 115 });
+            new Rgba64(x, y, z, w).ToRgba32(ref rgba);
+            Assert.Equal(rgba, new Rgba32(20, 38, 76, 115));
 
-            new Rgba64(x, y, z, w).ToZyxBytes(bgr, 0);
-            Assert.Equal(bgr, new byte[] { 76, 38, 20 });
+            new Rgba64(x, y, z, w).ToBgr24(ref bgr);
+            Assert.Equal(bgr, new Bgr24(20, 38, 76));
 
-            new Rgba64(x, y, z, w).ToZyxwBytes(bgra, 0);
-            Assert.Equal(bgra, new byte[] { 76, 38, 20, 115 });
+            new Rgba64(x, y, z, w).ToBgra32(ref bgra);
+            Assert.Equal(bgra, new Bgra32(20, 38, 76, 115));
 
-            Rgba64 r = new Rgba64();
+            var r = new Rgba64();
             r.PackFromRgba32(new Rgba32(20, 38, 76, 115));
-            r.ToXyzwBytes(rgba, 0);
-            Assert.Equal(rgba, new byte[] { 20, 38, 76, 115 });
+            r.ToRgba32(ref rgba);
+            Assert.Equal(rgba, new Rgba32(20, 38, 76, 115));
         }
 
         [Fact]
@@ -834,27 +833,27 @@ namespace SixLabors.ImageSharp.Tests.Colors
             y = -5.3f;
             Assert.Equal(4294639744, new Short2(x, y).PackedValue);
 
-            byte[] rgb = new byte[3];
-            byte[] rgba = new byte[4];
-            byte[] bgr = new byte[3];
-            byte[] bgra = new byte[4];
+            var rgb = default(Rgb24);
+            var rgba = default(Rgba32);
+            var bgr = default(Bgr24);
+            var bgra = default(Bgra32);
 
-            new Short2(x, y).ToXyzBytes(rgb, 0);
-            Assert.Equal(rgb, new byte[] { 128, 127, 0 });
+            new Short2(x, y).ToRgb24(ref rgb);
+            Assert.Equal(rgb, new Rgb24(128, 127, 0));
 
-            new Short2(x, y).ToXyzwBytes(rgba, 0);
-            Assert.Equal(rgba, new byte[] { 128, 127, 0, 255 });
+            new Short2(x, y).ToRgba32(ref rgba);
+            Assert.Equal(rgba, new Rgba32(128, 127, 0, 255));
 
-            new Short2(x, y).ToZyxBytes(bgr, 0);
-            Assert.Equal(bgr, new byte[] { 0, 127, 128 });
+            new Short2(x, y).ToBgr24(ref bgr);
+            Assert.Equal(bgr, new Bgr24(128, 127, 0));
 
-            new Short2(x, y).ToZyxwBytes(bgra, 0);
-            Assert.Equal(bgra, new byte[] { 0, 127, 128, 255 });
+            new Short2(x, y).ToBgra32(ref bgra);
+            Assert.Equal(bgra, new Bgra32(128, 127, 0, 255));
 
-            Short2 r = new Short2();
+            var r = new Short2();
             r.PackFromRgba32(new Rgba32(20, 38, 0, 255));
-            r.ToXyzwBytes(rgba, 0);
-            Assert.Equal(rgba, new byte[] { 20, 38, 0, 255 });
+            r.ToRgba32(ref rgba);
+            Assert.Equal(rgba, new Rgba32(20, 38, 0, 255));
         }
 
         [Fact]
@@ -891,27 +890,27 @@ namespace SixLabors.ImageSharp.Tests.Colors
             w = 193;
             Assert.Equal((ulong)0x00c173b7316d2d1b, new Short4(x, y, z, w).PackedValue);
 
-            byte[] rgb = new byte[3];
-            byte[] rgba = new byte[4];
-            byte[] bgr = new byte[3];
-            byte[] bgra = new byte[4];
+            var rgb = default(Rgb24);
+            var rgba = default(Rgba32);
+            var bgr = default(Bgr24);
+            var bgra = default(Bgra32);
 
-            new Short4(x, y, z, w).ToXyzBytes(rgb, 0);
-            Assert.Equal(rgb, new byte[] { 172, 177, 243 });
+            new Short4(x, y, z, w).ToRgb24(ref rgb);
+            Assert.Equal(rgb, new Rgb24(172, 177, 243));
 
-            new Short4(x, y, z, w).ToXyzwBytes(rgba, 0);
-            Assert.Equal(rgba, new byte[] { 172, 177, 243, 128 });
+            new Short4(x, y, z, w).ToRgba32(ref rgba);
+            Assert.Equal(rgba, new Rgba32(172, 177, 243, 128));
 
-            new Short4(x, y, z, w).ToZyxBytes(bgr, 0);
-            Assert.Equal(bgr, new byte[] { 243, 177, 172 });
+            new Short4(x, y, z, w).ToBgr24(ref bgr);
+            Assert.Equal(bgr, new Bgr24(172, 177, 243));
 
-            new Short4(x, y, z, w).ToZyxwBytes(bgra, 0);
-            Assert.Equal(bgra, new byte[] { 243, 177, 172, 128 });
+            new Short4(x, y, z, w).ToBgra32(ref bgra);
+            Assert.Equal(bgra, new Bgra32(172, 177, 243, 128));
 
-            Short4 r = new Short4();
+            var r = new Short4();
             r.PackFromRgba32(new Rgba32(20, 38, 0, 255));
-            r.ToXyzwBytes(rgba, 0);
-            Assert.Equal(rgba, new byte[] { 20, 38, 0, 255 });
+            r.ToRgba32(ref rgba);
+            Assert.Equal(rgba, new Rgba32(20, 38, 0, 255));
         }
 
         // Comparison helpers with small tolerance to allow for floating point rounding during computations.
diff --git a/tests/ImageSharp.Tests/PixelFormats/PixelOperationsTests.cs b/tests/ImageSharp.Tests/PixelFormats/PixelOperationsTests.cs
index dbb9a6c24..0fde67d28 100644
--- a/tests/ImageSharp.Tests/PixelFormats/PixelOperationsTests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/PixelOperationsTests.cs
@@ -173,11 +173,15 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
         {
             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;
-                source[i].ToXyzBytes(expected, i3);
+                source[i].ToRgb24(ref rgb);
+                expected[i3] = rgb.R;
+                expected[i3 + 1] = rgb.G;
+                expected[i3 + 2] = rgb.B;
             }
 
             TestOperation(
@@ -214,11 +218,16 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
         {
             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;
-                source[i].ToXyzwBytes(expected, i4);
+                source[i].ToRgba32(ref rgba);
+                expected[i4] = rgba.R;
+                expected[i4 + 1] = rgba.G;
+                expected[i4 + 2] = rgba.B;
+                expected[i4 + 3] = rgba.A;
             }
 
             TestOperation(
@@ -255,11 +264,15 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
         {
             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;
-                source[i].ToZyxBytes(expected, i3);
+                source[i].ToBgr24(ref bgr);
+                expected[i3] = bgr.B;
+                expected[i3 + 1] = bgr.G;
+                expected[i3 + 2] = bgr.R;
             }
 
             TestOperation(
@@ -296,11 +309,16 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
         {
             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;
-                source[i].ToZyxwBytes(expected, i4);
+                source[i].ToBgra32(ref bgra);
+                expected[i4] = bgra.B;
+                expected[i4 + 1] = bgra.G;
+                expected[i4 + 2] = bgra.R;
+                expected[i4 + 3] = bgra.A;
             }
 
             TestOperation(
diff --git a/tests/ImageSharp.Tests/PixelFormats/UnPackedPixelTests.cs b/tests/ImageSharp.Tests/PixelFormats/UnPackedPixelTests.cs
index b5d46ba76..1fca398fc 100644
--- a/tests/ImageSharp.Tests/PixelFormats/UnPackedPixelTests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/UnPackedPixelTests.cs
@@ -12,8 +12,8 @@ namespace SixLabors.ImageSharp.Tests.Colors
         [Fact]
         public void Color_Types_From_Bytes_Produce_Equal_Scaled_Component_OutPut()
         {
-            Rgba32 color = new Rgba32(24, 48, 96, 192);
-            RgbaVector colorVector = new RgbaVector(24, 48, 96, 192);
+            var color = new Rgba32(24, 48, 96, 192);
+            var colorVector = new RgbaVector(24, 48, 96, 192);
 
             Assert.Equal(color.R, (byte)(colorVector.R * 255));
             Assert.Equal(color.G, (byte)(colorVector.G * 255));
@@ -24,8 +24,8 @@ namespace SixLabors.ImageSharp.Tests.Colors
         [Fact]
         public void Color_Types_From_Floats_Produce_Equal_Scaled_Component_OutPut()
         {
-            Rgba32 color = new Rgba32(24 / 255F, 48 / 255F, 96 / 255F, 192 / 255F);
-            RgbaVector colorVector = new RgbaVector(24 / 255F, 48 / 255F, 96 / 255F, 192 / 255F);
+            var color = new Rgba32(24 / 255F, 48 / 255F, 96 / 255F, 192 / 255F);
+            var colorVector = new RgbaVector(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 @@ namespace SixLabors.ImageSharp.Tests.Colors
         [Fact]
         public void Color_Types_From_Vector4_Produce_Equal_Scaled_Component_OutPut()
         {
-            Rgba32 color = new Rgba32(new Vector4(24 / 255F, 48 / 255F, 96 / 255F, 192 / 255F));
-            RgbaVector colorVector = new RgbaVector(new Vector4(24 / 255F, 48 / 255F, 96 / 255F, 192 / 255F));
+            var color = new Rgba32(new Vector4(24 / 255F, 48 / 255F, 96 / 255F, 192 / 255F));
+            var colorVector = new RgbaVector(new Vector4(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 @@ namespace SixLabors.ImageSharp.Tests.Colors
         [Fact]
         public void Color_Types_From_Vector3_Produce_Equal_Scaled_Component_OutPut()
         {
-            Rgba32 color = new Rgba32(new Vector3(24 / 255F, 48 / 255F, 96 / 255F));
-            RgbaVector colorVector = new RgbaVector(new Vector3(24 / 255F, 48 / 255F, 96 / 255F));
+            var color = new Rgba32(new Vector3(24 / 255F, 48 / 255F, 96 / 255F));
+            var colorVector = new RgbaVector(new Vector3(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 @@ namespace SixLabors.ImageSharp.Tests.Colors
         [Fact]
         public void Color_Types_From_Hex_Produce_Equal_Scaled_Component_OutPut()
         {
-            Rgba32 color = Rgba32.FromHex("183060C0");
-            RgbaVector colorVector = RgbaVector.FromHex("183060C0");
+            var color = Rgba32.FromHex("183060C0");
+            var colorVector = RgbaVector.FromHex("183060C0");
 
             Assert.Equal(color.R, (byte)(colorVector.R * 255));
             Assert.Equal(color.G, (byte)(colorVector.G * 255));
@@ -72,8 +72,8 @@ namespace SixLabors.ImageSharp.Tests.Colors
         [Fact]
         public void Color_Types_To_Vector4_Produce_Equal_OutPut()
         {
-            Rgba32 color = new Rgba32(24, 48, 96, 192);
-            RgbaVector colorVector = new RgbaVector(24, 48, 96, 192);
+            var color = new Rgba32(24, 48, 96, 192);
+            var colorVector = new RgbaVector(24, 48, 96, 192);
 
             Assert.Equal(color.ToVector4(), colorVector.ToVector4());
         }
@@ -81,14 +81,14 @@ namespace SixLabors.ImageSharp.Tests.Colors
         [Fact]
         public void Color_Types_To_RgbBytes_Produce_Equal_OutPut()
         {
-            Rgba32 color = new Rgba32(24, 48, 96, 192);
-            RgbaVector colorVector = new RgbaVector(24, 48, 96, 192);
+            var color = new Rgba32(24, 48, 96, 192);
+            var colorVector = new RgbaVector(24, 48, 96, 192);
 
-            byte[] rgb = new byte[3];
-            byte[] rgbVector = new byte[3];
+            var rgb = default(Rgb24);
+            var rgbVector = default(Rgb24);
 
-            color.ToXyzBytes(rgb, 0);
-            colorVector.ToXyzBytes(rgbVector, 0);
+            color.ToRgb24(ref rgb);
+            colorVector.ToRgb24(ref rgbVector);
 
             Assert.Equal(rgb, rgbVector);
         }
@@ -96,14 +96,14 @@ namespace SixLabors.ImageSharp.Tests.Colors
         [Fact]
         public void Color_Types_To_RgbaBytes_Produce_Equal_OutPut()
         {
-            Rgba32 color = new Rgba32(24, 48, 96, 192);
-            RgbaVector colorVector = new RgbaVector(24, 48, 96, 192);
+            var color = new Rgba32(24, 48, 96, 192);
+            var colorVector = new RgbaVector(24, 48, 96, 192);
 
-            byte[] rgba = new byte[4];
-            byte[] rgbaVector = new byte[4];
+            var rgba = default(Rgba32);
+            var rgbaVector = default(Rgba32);
 
-            color.ToXyzwBytes(rgba, 0);
-            colorVector.ToXyzwBytes(rgbaVector, 0);
+            color.ToRgba32(ref rgba);
+            colorVector.ToRgba32(ref rgbaVector);
 
             Assert.Equal(rgba, rgbaVector);
         }
@@ -111,14 +111,14 @@ namespace SixLabors.ImageSharp.Tests.Colors
         [Fact]
         public void Color_Types_To_BgrBytes_Produce_Equal_OutPut()
         {
-            Rgba32 color = new Rgba32(24, 48, 96, 192);
-            RgbaVector colorVector = new RgbaVector(24, 48, 96, 192);
+            var color = new Rgba32(24, 48, 96, 192);
+            var colorVector = new RgbaVector(24, 48, 96, 192);
 
-            byte[] bgr = new byte[3];
-            byte[] bgrVector = new byte[3];
+            var bgr = default(Bgr24);
+            var bgrVector = default(Bgr24);
 
-            color.ToZyxBytes(bgr, 0);
-            colorVector.ToZyxBytes(bgrVector, 0);
+            color.ToBgr24(ref bgr);
+            colorVector.ToBgr24(ref bgrVector);
 
             Assert.Equal(bgr, bgrVector);
         }
@@ -126,14 +126,14 @@ namespace SixLabors.ImageSharp.Tests.Colors
         [Fact]
         public void Color_Types_To_BgraBytes_Produce_Equal_OutPut()
         {
-            Rgba32 color = new Rgba32(24, 48, 96, 192);
-            RgbaVector colorVector = new RgbaVector(24, 48, 96, 192);
+            var color = new Rgba32(24, 48, 96, 192);
+            var colorVector = new RgbaVector(24, 48, 96, 192);
 
-            byte[] bgra = new byte[4];
-            byte[] bgraVector = new byte[4];
+            var bgra = default(Bgra32);
+            var bgraVector = default(Bgra32);
 
-            color.ToZyxwBytes(bgra, 0);
-            colorVector.ToZyxwBytes(bgraVector, 0);
+            color.ToBgra32(ref bgra);
+            colorVector.ToBgra32(ref bgraVector);
 
             Assert.Equal(bgra, bgraVector);
         }
@@ -141,8 +141,8 @@ namespace SixLabors.ImageSharp.Tests.Colors
         [Fact]
         public void Color_Types_To_Hex_Produce_Equal_OutPut()
         {
-            Rgba32 color = new Rgba32(24, 48, 96, 192);
-            RgbaVector colorVector = new RgbaVector(24, 48, 96, 192);
+            var color = new Rgba32(24, 48, 96, 192);
+            var colorVector = new RgbaVector(24, 48, 96, 192);
 
             // 183060C0
             Assert.Equal(color.ToHex(), colorVector.ToHex());
diff --git a/tests/ImageSharp.Tests/Processing/Processors/ColorMatrix/GrayscaleTest.cs b/tests/ImageSharp.Tests/Processing/Processors/ColorMatrix/GrayscaleTest.cs
index fe003da32..0fbc54b8f 100644
--- a/tests/ImageSharp.Tests/Processing/Processors/ColorMatrix/GrayscaleTest.cs
+++ b/tests/ImageSharp.Tests/Processing/Processors/ColorMatrix/GrayscaleTest.cs
@@ -31,13 +31,13 @@ namespace SixLabors.ImageSharp.Tests.Processing.Processors.ColorMatrix
             using (Image<TPixel> image = provider.GetImage())
             {
                 image.Mutate(x => x.Grayscale(value));
-                byte[] data = new byte[3];
+                var rgb = default(Rgb24);
                 System.Span<TPixel> span = image.Frames.RootFrame.GetPixelSpan();
                 for (int i = 0; i < span.Length; i++)
                 {
-                    span[i].ToXyzBytes(data, 0);
-                    Assert.Equal(data[0], data[1]);
-                    Assert.Equal(data[1], data[2]);
+                    span[i].ToRgb24(ref rgb);
+                    Assert.Equal(rgb.R, rgb.B);
+                    Assert.Equal(rgb.B, rgb.G);
                 }
 
                 image.DebugSave(provider, value.ToString());
@@ -50,7 +50,7 @@ namespace SixLabors.ImageSharp.Tests.Processing.Processors.ColorMatrix
             where TPixel : struct, IPixel<TPixel>
         {
             using (Image<TPixel> source = provider.GetImage())
-            using (var image = source.Clone())
+            using (Image<TPixel> image = source.Clone())
             {
                 var bounds = new Rectangle(image.Width / 4, image.Height / 4, image.Width / 2, image.Height / 2);
                 image.Mutate(x => x.Grayscale(value, bounds));
diff --git a/tests/ImageSharp.Tests/TestUtilities/TestUtils.cs b/tests/ImageSharp.Tests/TestUtilities/TestUtils.cs
index 83997841a..a468c2116 100644
--- a/tests/ImageSharp.Tests/TestUtilities/TestUtils.cs
+++ b/tests/ImageSharp.Tests/TestUtilities/TestUtils.cs
@@ -54,8 +54,8 @@ namespace SixLabors.ImageSharp.Tests
                 return false;
             }
 
-            byte[] bytesA = new byte[3];
-            byte[] bytesB = new byte[3];
+            var rgb1 = default(Rgb24);
+            var rgb2 = default(Rgb24);
 
             using (PixelAccessor<TPixel> pixA = a.Lock())
             {
@@ -77,12 +77,12 @@ namespace SixLabors.ImageSharp.Tests
                             }
                             else
                             {
-                                ca.ToXyzBytes(bytesA, 0);
-                                cb.ToXyzBytes(bytesB, 0);
+                                ca.ToRgb24(ref rgb1);
+                                cb.ToRgb24(ref rgb2);
 
-                                if (bytesA[0] != bytesB[0] ||
-                                    bytesA[1] != bytesB[1] ||
-                                    bytesA[2] != bytesB[2])
+                                if (rgb1.R != rgb2.R ||
+                                    rgb1.G != rgb2.G ||
+                                    rgb1.B != rgb2.B)
                                 {
                                     return false;
                                 }
@@ -109,7 +109,7 @@ namespace SixLabors.ImageSharp.Tests
         /// <returns></returns>
         public static PixelTypes GetPixelType(this Type colorStructClrType) => ClrTypes2PixelTypes[colorStructClrType];
 
-        
+
 
         public static IEnumerable<KeyValuePair<PixelTypes, Type>> ExpandAllTypes(this PixelTypes pixelTypes)
         {
diff --git a/tests/ImageSharp.Tests/TestUtilities/Tests/TestImageProviderTests.cs b/tests/ImageSharp.Tests/TestUtilities/Tests/TestImageProviderTests.cs
index 88d7fa2b8..e3249fae9 100644
--- a/tests/ImageSharp.Tests/TestUtilities/Tests/TestImageProviderTests.cs
+++ b/tests/ImageSharp.Tests/TestUtilities/Tests/TestImageProviderTests.cs
@@ -57,7 +57,7 @@ namespace SixLabors.ImageSharp.Tests
         {
             Assert.Equal(expected, provider.PixelType);
         }
-        
+
         [Theory]
         [WithFile(TestImages.Bmp.Car, PixelTypes.All, 88)]
         [WithFile(TestImages.Bmp.F, PixelTypes.All, 88)]
@@ -96,7 +96,7 @@ namespace SixLabors.ImageSharp.Tests
             }
 
             internal static int GetInvocationCount(string callerName) => invocationCounts[callerName];
-            
+
             private static readonly object Monitor = new object();
 
             public static void DoTestThreadSafe(Action action)
@@ -156,7 +156,7 @@ namespace SixLabors.ImageSharp.Tests
             }
 
             internal static int GetInvocationCount(string callerName) => invocationCounts[callerName];
-            
+
             private static readonly object Monitor = new object();
 
             public static void DoTestThreadSafe(Action action)
@@ -234,7 +234,7 @@ namespace SixLabors.ImageSharp.Tests
             Image<TPixel> image = provider.GetImage();
             provider.Utility.SaveTestOutputFile(image, "png");
         }
-        
+
         [Theory]
         [WithSolidFilledImages(10, 20, 255, 100, 50, 200, PixelTypes.Rgba32 | PixelTypes.Argb32)]
         public void Use_WithSolidFilledImagesAttribute<TPixel>(TestImageProvider<TPixel> provider)
@@ -244,7 +244,7 @@ namespace SixLabors.ImageSharp.Tests
             Assert.Equal(10, img.Width);
             Assert.Equal(20, img.Height);
 
-            byte[] colors = new byte[4];
+            var rgba = default(Rgba32);
 
             using (PixelAccessor<TPixel> pixels = img.Lock())
             {
@@ -252,12 +252,12 @@ namespace SixLabors.ImageSharp.Tests
                 {
                     for (int x = 0; x < pixels.Width; x++)
                     {
-                        pixels[x, y].ToXyzwBytes(colors, 0);
+                        pixels[x, y].ToRgba32(ref rgba);
 
-                        Assert.Equal(255, colors[0]);
-                        Assert.Equal(100, colors[1]);
-                        Assert.Equal(50, colors[2]);
-                        Assert.Equal(200, colors[3]);
+                        Assert.Equal(255, rgba.R);
+                        Assert.Equal(100, rgba.G);
+                        Assert.Equal(50, rgba.B);
+                        Assert.Equal(200, rgba.A);
                     }
                 }
             }