diff --git a/sources/Maths/Maths/Legacy/Vector2D.Ops.cs b/sources/Maths/Maths/Legacy/Vector2D.Ops.cs
index 3c556c26d3..df68ebed3b 100644
--- a/sources/Maths/Maths/Legacy/Vector2D.Ops.cs
+++ b/sources/Maths/Maths/Legacy/Vector2D.Ops.cs
@@ -213,7 +213,7 @@ public static Vector2D<T> TransformNormal<T>(Vector2D<T> normal, Matrix4X4<T> ma
         /// <param name="value">The source vector to be rotated.</param>
         /// <param name="rotation">The rotation to apply.</param>
         /// <returns>The transformed vector.</returns>
-        public static Vector2D<T> Transform<T>(Vector2D<T> value, Quaternion<T> rotation)
+        public static Vector2D<T> Transform<T>(Vector2D<T> value, Legacy.Quaternion<T> rotation)
             where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
         {
             T x2 = Scalar.Add(rotation.X, rotation.X);
@@ -285,4 +285,4 @@ public static Vector2D<T> Multiply<T>(Vector2D<T> value1, Matrix2X2<T> value2)
             where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
             => value1 * value2;
     }
-}
\ No newline at end of file
+}
diff --git a/sources/Maths/Maths/Legacy/Vector3D.Ops.cs b/sources/Maths/Maths/Legacy/Vector3D.Ops.cs
index ec06f40112..618c53b805 100644
--- a/sources/Maths/Maths/Legacy/Vector3D.Ops.cs
+++ b/sources/Maths/Maths/Legacy/Vector3D.Ops.cs
@@ -254,7 +254,7 @@ public static Vector3D<T> Transform<T>(Vector3D<T> position, Matrix4X4<T> matrix
         /// <param name="rotation">The rotation to apply.</param>
         /// <returns>The transformed vector.</returns>
         [MethodImpl((MethodImplOptions) 768)]
-        public static Vector3D<T> Transform<T>(Vector3D<T> value, Quaternion<T> rotation)
+        public static Vector3D<T> Transform<T>(Vector3D<T> value, Legacy.Quaternion<T> rotation)
             where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
         {
             T x2 = Scalar.Add(rotation.X, rotation.X);
@@ -296,4 +296,4 @@ public static Vector3D<T> TransformNormal<T>(Vector3D<T> normal, Matrix4X4<T> ma
             );
         }
     }
-}
\ No newline at end of file
+}
diff --git a/sources/Maths/Maths/Legacy/Vector4D.Ops.cs b/sources/Maths/Maths/Legacy/Vector4D.Ops.cs
index 16caebd93b..b86726fc19 100644
--- a/sources/Maths/Maths/Legacy/Vector4D.Ops.cs
+++ b/sources/Maths/Maths/Legacy/Vector4D.Ops.cs
@@ -237,7 +237,7 @@ public static Vector4D<T> Transform<T>(Vector2D<T> position, Matrix4X4<T> matrix
         /// <param name="rotation">The rotation to apply.</param>
         /// <returns>The transformed vector.</returns>
         [MethodImpl((MethodImplOptions) 768)]
-        public static Vector4D<T> Transform<T>(Vector2D<T> value, Quaternion<T> rotation)
+        public static Vector4D<T> Transform<T>(Vector2D<T> value, Silk.NET.Maths.Legacy.Quaternion<T> rotation)
             where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
         {
             T x2 = Scalar.Add(rotation.X, rotation.X);
@@ -283,7 +283,7 @@ public static Vector4D<T> Transform<T>(Vector3D<T> position, Matrix4X4<T> matrix
         /// <param name="rotation">The rotation to apply.</param>
         /// <returns>The transformed vector.</returns>
         [MethodImpl((MethodImplOptions) 768)]
-        public static Vector4D<T> Transform<T>(Vector3D<T> value, Quaternion<T> rotation)
+        public static Vector4D<T> Transform<T>(Vector3D<T> value, Legacy.Quaternion<T> rotation)
             where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
         {
             T x2 = Scalar.Add(rotation.X, rotation.X);
@@ -329,7 +329,7 @@ public static Vector4D<T> Transform<T>(Vector4D<T> vector, Matrix4X4<T> matrix)
         /// <param name="rotation">The rotation to apply.</param>
         /// <returns>The transformed vector.</returns>
         [MethodImpl((MethodImplOptions) 768)]
-        public static Vector4D<T> Transform<T>(Vector4D<T> value, Quaternion<T> rotation)
+        public static Vector4D<T> Transform<T>(Vector4D<T> value, Legacy.Quaternion<T> rotation)
             where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
         {
             T x2 = Scalar.Add(rotation.X, rotation.X);
@@ -354,4 +354,4 @@ public static Vector4D<T> Transform<T>(Vector4D<T> value, Quaternion<T> rotation
             );
         }
     }
-}
\ No newline at end of file
+}
diff --git a/sources/Maths/Maths/Matrix2X3.Ops.cs b/sources/Maths/Maths/Matrix2X3.Ops.cs
index 242912de0b..6ebb6124ca 100644
--- a/sources/Maths/Maths/Matrix2X3.Ops.cs
+++ b/sources/Maths/Maths/Matrix2X3.Ops.cs
@@ -104,7 +104,7 @@ public static Matrix2X3<T> CreateFromAxisAngle<T>(Vector3D<T> axis, T angle)
         /// <summary>Creates a rotation matrix from the given Quaternion rotation value.</summary>
         /// <param name="quaternion">The source Quaternion.</param>
         /// <returns>The rotation matrix.</returns>
-        public static Matrix2X3<T> CreateFromQuaternion<T>(Quaternion<T> quaternion)
+        public static Matrix2X3<T> CreateFromQuaternion<T>(Silk.NET.Maths.Legacy.Quaternion<T> quaternion)
             where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
         {
             Matrix2X3<T> result = Matrix2X3<T>.Identity;
@@ -140,7 +140,7 @@ public static Matrix2X3<T> CreateFromQuaternion<T>(Quaternion<T> quaternion)
         public static Matrix2X3<T> CreateFromYawPitchRoll<T>(T yaw, T pitch, T roll)
             where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
         {
-            Quaternion<T> q = Quaternion<T>.CreateFromYawPitchRoll(yaw, pitch, roll);
+            Legacy.Quaternion<T> q = Legacy.Quaternion<T>.CreateFromYawPitchRoll(yaw, pitch, roll);
             return CreateFromQuaternion(q);
         }
 
@@ -223,7 +223,7 @@ public static unsafe Matrix2X3<T> Lerp<T>(Matrix2X3<T> matrix1, Matrix2X3<T> mat
         /// <param name="value">The source matrix to transform.</param>
         /// <param name="rotation">The rotation to apply.</param>
         /// <returns>The transformed matrix.</returns>
-        public static Matrix2X3<T> Transform<T>(Matrix2X3<T> value, Quaternion<T> rotation)
+        public static Matrix2X3<T> Transform<T>(Matrix2X3<T> value, Legacy.Quaternion<T> rotation)
             where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
         {
             // Compute rotation matrix.
@@ -260,4 +260,4 @@ public static Matrix2X3<T> Transform<T>(Matrix2X3<T> value, Quaternion<T> rotati
             return new(value.M11 * q1 + value.M12 * q2 + value.M13 * q3, value.M21 * q1 + value.M22 * q2 + value.M23 * q3);
         }
     }
-}
\ No newline at end of file
+}
diff --git a/sources/Maths/Maths/Matrix3X3.Ops.cs b/sources/Maths/Maths/Matrix3X3.Ops.cs
index 2b11c28756..aa3905c23a 100644
--- a/sources/Maths/Maths/Matrix3X3.Ops.cs
+++ b/sources/Maths/Maths/Matrix3X3.Ops.cs
@@ -127,7 +127,7 @@ public static Matrix3X3<T> CreateFromAxisAngle<T>(Vector3D<T> axis, T angle)
         /// <summary>Creates a rotation matrix from the given Quaternion rotation value.</summary>
         /// <param name="quaternion">The source Quaternion.</param>
         /// <returns>The rotation matrix.</returns>
-        public static Matrix3X3<T> CreateFromQuaternion<T>(Quaternion<T> quaternion)
+        public static Matrix3X3<T> CreateFromQuaternion<T>(Silk.NET.Maths.Legacy.Quaternion<T> quaternion)
             where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
         {
             Matrix3X3<T> result = Matrix3X3<T>.Identity;
@@ -167,7 +167,7 @@ public static Matrix3X3<T> CreateFromQuaternion<T>(Quaternion<T> quaternion)
         public static Matrix3X3<T> CreateFromYawPitchRoll<T>(T yaw, T pitch, T roll)
             where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
         {
-            Quaternion<T> q = Quaternion<T>.CreateFromYawPitchRoll(yaw, pitch, roll);
+            Legacy.Quaternion<T> q = Legacy.Quaternion<T>.CreateFromYawPitchRoll(yaw, pitch, roll);
             return CreateFromQuaternion(q);
         }
 
@@ -373,7 +373,7 @@ public static Matrix3X3<T> Subtract<T>(Matrix3X3<T> value1, Matrix3X3<T> value2)
         /// <param name="scale">The scaling component of the transformation matrix.</param>
         /// <param name="rotation">The rotation component of the transformation matrix.</param>
         /// <returns>True if the source matrix was successfully decomposed; False otherwise.</returns>
-        public static bool Decompose<T>(Matrix3X3<T> matrix, out Vector3D<T> scale, out Quaternion<T> rotation)
+        public static bool Decompose<T>(Matrix3X3<T> matrix, out Vector3D<T> scale, out Silk.NET.Maths.Legacy.Quaternion<T> rotation)
             where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
         {
             bool result = true;
@@ -546,13 +546,13 @@ public static bool Decompose<T>(Matrix3X3<T> matrix, out Vector3D<T> scale, out
                     if (!Scalar.GreaterThanOrEqual(Scalar.As<float, T>(DecomposeEpsilon), det))
                     {
                         // Non-SRT matrix encountered
-                        rotation = Quaternion<T>.Identity;
+                        rotation = Legacy.Quaternion<T>.Identity;
                         result = false;
                     }
                     else
                     {
                         // generate the quaternion from the matrix
-                        rotation = Quaternion<T>.CreateFromRotationMatrix(matTemp);
+                        rotation = Legacy.Quaternion<T>.CreateFromRotationMatrix(matTemp);
                     }
                 }
             }
@@ -579,7 +579,7 @@ public static unsafe Matrix3X3<T> Lerp<T>(Matrix3X3<T> matrix1, Matrix3X3<T> mat
         /// <param name="value">The source matrix to transform.</param>
         /// <param name="rotation">The rotation to apply.</param>
         /// <returns>The transformed matrix.</returns>
-        public static Matrix3X3<T> Transform<T>(Matrix3X3<T> value, Quaternion<T> rotation)
+        public static Matrix3X3<T> Transform<T>(Matrix3X3<T> value, Legacy.Quaternion<T> rotation)
             where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
         {
             // Compute rotation matrix.
@@ -625,4 +625,4 @@ public static unsafe Matrix3X3<T> Transpose<T>(Matrix3X3<T> matrix)
             return new(matrix.Column1, matrix.Column2, matrix.Column3);
         }
     }
-}
\ No newline at end of file
+}
diff --git a/sources/Maths/Maths/Matrix4X4.Ops.cs b/sources/Maths/Maths/Matrix4X4.Ops.cs
index d27a6128ae..fb74c4345a 100644
--- a/sources/Maths/Maths/Matrix4X4.Ops.cs
+++ b/sources/Maths/Maths/Matrix4X4.Ops.cs
@@ -197,7 +197,7 @@ public static Matrix4X4<T> CreateFromAxisAngle<T>(Vector3D<T> axis, T angle)
         /// <summary>Creates a rotation matrix from the given Quaternion rotation value.</summary>
         /// <param name="quaternion">The source Quaternion.</param>
         /// <returns>The rotation matrix.</returns>
-        public static Matrix4X4<T> CreateFromQuaternion<T>(Quaternion<T> quaternion)
+        public static Matrix4X4<T> CreateFromQuaternion<T>(Silk.NET.Maths.Legacy.Quaternion<T> quaternion)
             where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
         {
             Matrix4X4<T> result = Matrix4X4<T>.Identity;
@@ -237,7 +237,7 @@ public static Matrix4X4<T> CreateFromQuaternion<T>(Quaternion<T> quaternion)
         public static Matrix4X4<T> CreateFromYawPitchRoll<T>(T yaw, T pitch, T roll)
             where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
         {
-            Quaternion<T> q = Quaternion<T>.CreateFromYawPitchRoll(yaw, pitch, roll);
+            Legacy.Quaternion<T> q = Legacy.Quaternion<T>.CreateFromYawPitchRoll(yaw, pitch, roll);
             return CreateFromQuaternion(q);
         }
 
@@ -1276,7 +1276,7 @@ private static Vector128<T> Permute(Vector128<T> value, byte control)
         /// <param name="rotation">The rotation component of the transformation matrix.</param>
         /// <param name="translation">The translation component of the transformation matrix</param>
         /// <returns>True if the source matrix was successfully decomposed; False otherwise.</returns>
-        public static bool Decompose<T>(Matrix4X4<T> matrix, out Vector3D<T> scale, out Quaternion<T> rotation, out Vector3D<T> translation)
+        public static bool Decompose<T>(Matrix4X4<T> matrix, out Vector3D<T> scale, out Silk.NET.Maths.Legacy.Quaternion<T> rotation, out Vector3D<T> translation)
             where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
         {
             bool result = true;
@@ -1454,13 +1454,13 @@ public static bool Decompose<T>(Matrix4X4<T> matrix, out Vector3D<T> scale, out
                     if (!Scalar.GreaterThanOrEqual(Scalar.As<float, T>(DecomposeEpsilon), det))
                     {
                         // Non-SRT matrix encountered
-                        rotation = Quaternion<T>.Identity;
+                        rotation = Legacy.Quaternion<T>.Identity;
                         result = false;
                     }
                     else
                     {
                         // generate the quaternion from the matrix
-                        rotation = Quaternion<T>.CreateFromRotationMatrix(matTemp);
+                        rotation = Legacy.Quaternion<T>.CreateFromRotationMatrix(matTemp);
                     }
                 }
             }
@@ -1488,7 +1488,7 @@ public static unsafe Matrix4X4<T> Lerp<T>(Matrix4X4<T> matrix1, Matrix4X4<T> mat
         /// <param name="value">The source matrix to transform.</param>
         /// <param name="rotation">The rotation to apply.</param>
         /// <returns>The transformed matrix.</returns>
-        public static Matrix4X4<T> Transform<T>(Matrix4X4<T> value, Quaternion<T> rotation)
+        public static Matrix4X4<T> Transform<T>(Matrix4X4<T> value, Legacy.Quaternion<T> rotation)
             where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
         {
             // Compute rotation matrix.
@@ -1539,4 +1539,4 @@ public static unsafe Matrix4X4<T> Transpose<T>(Matrix4X4<T> matrix)
             return new(matrix.Column1, matrix.Column2, matrix.Column3, matrix.Column4);
         }
     }
-}
\ No newline at end of file
+}
diff --git a/sources/Maths/Maths/Plane.Ops.cs b/sources/Maths/Maths/Plane.Ops.cs
index ec15e8de18..24879072fb 100644
--- a/sources/Maths/Maths/Plane.Ops.cs
+++ b/sources/Maths/Maths/Plane.Ops.cs
@@ -181,7 +181,7 @@ public static Plane<T> Transform<T>(Plane<T> plane, Matrix4X4<T> matrix)
         /// <param name="rotation">The Quaternion rotation to apply to the Plane.</param>
         /// <returns>A new Plane that results from applying the rotation.</returns>
         [MethodImpl((MethodImplOptions) 768)]
-        public static Plane<T> Transform<T>(Plane<T> plane, Quaternion<T> rotation)
+        public static Plane<T> Transform<T>(Plane<T> plane, Legacy.Quaternion<T> rotation)
             where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
         {
             // Compute rotation matrix.
@@ -220,4 +220,4 @@ public static Plane<T> Transform<T>(Plane<T> plane, Quaternion<T> rotation)
                 plane.Distance);
         }
     }
-}
\ No newline at end of file
+}
diff --git a/sources/Maths/Maths/Vector2F.cs b/sources/Maths/Maths/Vector2F.cs
index 10c855434b..843f180af2 100644
--- a/sources/Maths/Maths/Vector2F.cs
+++ b/sources/Maths/Maths/Vector2F.cs
@@ -14,75 +14,8 @@
 namespace Silk.NET.Maths
 {
     /// <summary>A structure representing a 2D floating-point vector.</summary>
-    internal partial struct Vector2F<T> :
-        ISpanFormattable,
-        ISpanParsable<Vector2F<T>>,
-        IUtf8SpanFormattable,
-        IUtf8SpanParsable<Vector2F<T>>,
-        IParsable<Vector2F<T>>,
-        IFormattable
-        where T : IFloatingPointIeee754<T>
+    internal partial struct Vector2F<T>
     {
-        /// <summary>Initializes the vector from a span of two values.</summary>
-        public Vector2F(ReadOnlySpan<T> values)
-        {
-            if (values.Length != 2)
-                throw new ArgumentException("Input span must contain exactly 2 elements.", nameof(values));
-
-            X = values[0];
-            Y = values[1];
-        }
-
-        /// <summary>Gets a vector whose 2 elements are equal to one.</summary>
-        public static Vector2F<T> One => new(Scalar<T>.One);
-
-        /// <summary>Returns a vector whose 2 elements are equal to zero.</summary>
-        public static Vector2F<T> Zero => default;
-
-        /// <summary>Gets the vector (1, 0).</summary>
-        public static Vector2F<T> UnitX => new(Scalar<T>.One, Scalar<T>.Zero);
-
-        /// <summary>Gets the vector (0, 1).</summary>
-        public static Vector2F<T> UnitY => new(Scalar<T>.Zero, Scalar<T>.One);
-
-        /// <summary>Gets a vector with all bits set for each component.</summary>
-        public static Vector2F<T> AllBitsSet => new(T.AllBitsSet, T.AllBitsSet);
-
-        /// <summary>Gets the squared length of the vector (dot product with itself).</summary>
-        public T LengthSquared => (X * X) + (Y * Y);
-
-        /// <summary>Gets the length of the vector.</summary>
-        public T Length => T.Sqrt(LengthSquared);
-
-        /// <summary> Computes the dot product of this vector with another vector. </summary>
-        public T Dot(Vector2F<T> other) => (X * other.X) + (Y * other.Y);
-
-        /// <summary> Computes the dot product of two vectors. </summary>
-        public static T Dot(Vector2F<T> left, Vector2F<T> right) => (left.X * right.X) + (left.Y * right.Y);
-
-        /// <summary> Computes the cross product of this vector with another vector. </summary>
-        public T Cross(Vector2F<T> other) => (X * other.Y) - (Y * other.X);
-
-        /// <summary> Computes the cross product of two vectors. </summary>
-        public static T Cross(Vector2F<T> left, Vector2F<T> right) => (left.X * right.Y) - (left.Y * right.X);
-
-        /// <summary>Returns a span over the vector components.</summary>
-        public Span<T> AsSpan() => MemoryMarshal.CreateSpan(ref X, 2);
-
-        /// <summary>Normalizes this vector.</summary>
-        public Vector2F<T> Normalize()
-        {
-            T length = Length;
-            return length != T.Zero ? this / length : Zero;
-        }
-
-        /// <summary>Normalizes a vector.</summary>
-        public static Vector2F<T> Normalize(Vector2F<T> vector)
-        {
-            T length = vector.Length;
-            return length != T.Zero ? vector / length : Zero;
-        }
-
         /// <summary>Returns a vector with the component-wise maximum of this and another vector.</summary>
         public Vector2F<T> Max(Vector2F<T> other) =>
             new(T.Max(X, other.X), T.Max(Y, other.Y));
@@ -157,100 +90,6 @@ public static Vector2F<T> LerpClamped(Vector2F<T> a, Vector2F<T> b, Vector2F<T>
                 a.Y + (b.Y - a.Y) * T.Clamp(t.Y, T.Zero, T.One)
             );
 
-        /// <summary>Reflects a vector over a normal vector.</summary>
-        public Vector2F<T> Reflect(Vector2F<T> normal)
-        {
-            T dot = Dot(normal);
-            return this - (normal * (dot + dot));
-        }
-
-        /// <summary>Reflects a vector over a normal vector.</summary>
-        public static Vector2F<T> Reflect(Vector2F<T> vector, Vector2F<T> normal)
-        {
-            T dot = Dot(vector, normal);
-            return vector - (normal * (dot + dot));
-        }
-
-        /// <summary>Formats the vector as a string using the specified format and format provider.</summary>
-        public string ToString(string? format, IFormatProvider? formatProvider) => $"<{X.ToString(format, formatProvider)}, {Y.ToString(format, formatProvider)}>";
-
-        /// <summary>Formats the vector as a string.</summary>
-        public override string ToString() => $"<{X}, {Y}>";
-
-        /// <summary>Formats the vector as a string using the specified format and format provider.</summary>
-        public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format, IFormatProvider? provider)
-        {
-            Span<char> xBuffer = stackalloc char[64];
-            Span<char> yBuffer = stackalloc char[64];
-
-            if (!X.TryFormat(xBuffer, out int xChars, format, provider) ||
-                !Y.TryFormat(yBuffer, out int yChars, format, provider))
-            {
-                charsWritten = 0;
-                return false;
-            }
-
-            int requiredLength = 1 + xChars + 2 + yChars + 1;
-
-            if (destination.Length < requiredLength)
-            {
-                charsWritten = 0;
-                return false;
-            }
-
-            int pos = 0;
-            destination[pos++] = '<';
-
-            xBuffer[..xChars].CopyTo(destination[pos..]);
-            pos += xChars;
-
-            destination[pos++] = ',';
-            destination[pos++] = ' ';
-
-            yBuffer[..yChars].CopyTo(destination[pos..]);
-            pos += yChars;
-
-            destination[pos++] = '>';
-
-            charsWritten = pos;
-            return true;
-        }
-
-        /// <summary>Parses a span to a <see cref="Vector2F{T}"/> instance.</summary>
-        public static Vector2F<T> Parse(ReadOnlySpan<char> s, IFormatProvider? provider)
-        {
-            if (!TryParse(s, provider, out var result))
-                throw new FormatException("Invalid format for Vector2F.");
-
-            return result;
-        }
-
-        /// <summary>Copies the components of the vector to the specified array starting at index 0.</summary>
-        public void CopyTo(T[] array) => CopyTo(array, 0);
-
-        /// <summary>Copies the components of the vector to the specified array starting at the given index.</summary>
-        public void CopyTo(T[] array, int startIndex)
-        {
-            if (array == null)
-                throw new ArgumentNullException(nameof(array));
-            if (startIndex < 0 || startIndex + 2 > array.Length)
-                throw new ArgumentOutOfRangeException(nameof(startIndex));
-            array[startIndex] = X;
-            array[startIndex + 1] = Y;
-        }
-
-        /// <summary>Copies the components of the vector to the specified span starting at index 0.</summary>
-        public void CopyTo(Span<T> span) => CopyTo(span, 0);
-
-        /// <summary>Copies the components of the vector to the specified span starting at the given index.</summary>
-        public void CopyTo(Span<T> span, int startIndex)
-        {
-            if (startIndex < 0 || startIndex + 2 > span.Length)
-                throw new ArgumentOutOfRangeException(nameof(startIndex));
-            span[startIndex] = X;
-            span[startIndex + 1] = Y;
-        }
-
         /// <summary>Returns a vector where each component is the sign of the original vector's component.</summary>
         public Vector2F<T> Sign() => new(T.CreateChecked(T.Sign(X)), T.CreateChecked(T.Sign(Y)));
 
@@ -274,110 +113,6 @@ public Vector2F<T> CopySign(T signScalar) =>
         public static Vector2F<T> CopySign(Vector2F<T> value, T signScalar) =>
             new(T.CopySign(value.X, signScalar), T.CopySign(value.Y, signScalar));
 
-        /// <summary>Parses a string to a <see cref="Vector2F{T}"/> instance.</summary>
-        public static Vector2F<T> Parse(string s, IFormatProvider? provider) => Parse(s.AsSpan(), provider);
-
-        /// <summary>Tries to parse a span to a <see cref="Vector2F{T}"/> instance.</summary>
-        public static bool TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector2F<T> result)
-        {
-            result = default;
-
-            s = s.Trim();
-            if (s.Length < 5 || s[0] != '<' || s[^1] != '>')
-                return false;
-
-            s = s[1..^1]; // Remove < and >
-
-            int commaIndex = s.IndexOf(',');
-            if (commaIndex < 0)
-                return false;
-
-            ReadOnlySpan<char> xSpan = s[..commaIndex].Trim();
-            ReadOnlySpan<char> ySpan = s[(commaIndex + 1)..].Trim();
-
-            if (T.TryParse(xSpan, provider, out var x) &&
-                T.TryParse(ySpan, provider, out var y))
-            {
-                result = new Vector2F<T>(x, y);
-                return true;
-            }
-
-            return false;
-        }
-
-        /// <summary>Tries to parse a string to a <see cref="Vector2F{T}"/> instance.</summary>
-        public static bool TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector2F<T> result) =>
-            TryParse(s.AsSpan(), provider, out result);
-
-        /// <summary>Parses a span to a <see cref="Vector2F{T}"/> instance.</summary>
-        static Vector2F<T> ISpanParsable<Vector2F<T>>.Parse(ReadOnlySpan<char> s, IFormatProvider? provider) =>
-            Parse(s, provider);
-
-        /// <summary>Parses a string to a <see cref="Vector2F{T}"/> instance.</summary>
-        static Vector2F<T> IParsable<Vector2F<T>>.Parse(string s, IFormatProvider? provider) =>
-            Parse(s, provider);
-
-        /// <summary>Tries to parse a span to a <see cref="Vector2F{T}"/> instance.</summary>
-        static bool ISpanParsable<Vector2F<T>>.TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector2F<T> result) =>
-            TryParse(s, provider, out result);
-
-        /// <summary>Tries to parse a string to a <see cref="Vector2F{T}"/> instance.</summary>
-        static bool IParsable<Vector2F<T>>.TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector2F<T> result) =>
-            TryParse(s, provider, out result);
-
-        /// <summary>Formats the vector as a UTF-8 string using the specified format and format provider.</summary>
-        public bool TryFormat(Span<byte> utf8Destination, out int bytesWritten, ReadOnlySpan<char> format, IFormatProvider? provider)
-        {
-            Span<char> xBuffer = stackalloc char[64];
-            Span<char> yBuffer = stackalloc char[64];
-
-            if (!X.TryFormat(xBuffer, out int xChars, format, provider) ||
-                !Y.TryFormat(yBuffer, out int yChars, format, provider))
-            {
-                bytesWritten = 0;
-                return false;
-            }
-
-            int estimatedSize = Encoding.UTF8.GetByteCount(xBuffer[..xChars]) +
-                                Encoding.UTF8.GetByteCount(yBuffer[..yChars]) +
-                                Encoding.UTF8.GetByteCount("<, >");
-
-            if (utf8Destination.Length < estimatedSize)
-            {
-                bytesWritten = 0;
-                return false;
-            }
-
-            int totalBytes = 0;
-
-            totalBytes += Encoding.UTF8.GetBytes("<", utf8Destination[totalBytes..]);
-            totalBytes += Encoding.UTF8.GetBytes(xBuffer[..xChars], utf8Destination[totalBytes..]);
-            totalBytes += Encoding.UTF8.GetBytes(", ", utf8Destination[totalBytes..]);
-            totalBytes += Encoding.UTF8.GetBytes(yBuffer[..yChars], utf8Destination[totalBytes..]);
-            totalBytes += Encoding.UTF8.GetBytes(">", utf8Destination[totalBytes..]);
-
-            bytesWritten = totalBytes;
-            return true;
-        }
-
-        /// <summary>Parses a UTF-8 span to a <see cref="Vector2F{T}"/> instance.</summary>
-        public static Vector2F<T> Parse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider)
-        {
-            int charCount = Encoding.UTF8.GetCharCount(utf8Text);
-            Span<char> charBuffer = charCount <= 128 ? stackalloc char[charCount] : new char[charCount];
-            Encoding.UTF8.GetChars(utf8Text, charBuffer);
-            return Parse(charBuffer, provider);
-        }
-
-        /// <summary>Tries to parse a UTF-8 span to a <see cref="Vector2F{T}"/> instance.</summary>
-        public static bool TryParse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector2F<T> result)
-        {
-            int charCount = Encoding.UTF8.GetCharCount(utf8Text);
-            Span<char> charBuffer = charCount <= 128 ? stackalloc char[charCount] : new char[charCount];
-            Encoding.UTF8.GetChars(utf8Text, charBuffer);
-            return TryParse(charBuffer, provider, out result);
-        }
-
         // Casts
 
         /// <summary>Explicitly casts a <see cref="System.Numerics.Vector2"/> to a <see cref="Vector2F{T}"/>.</summary>
@@ -388,45 +123,6 @@ public static explicit operator Vector2F<T>(System.Numerics.Vector2 v) =>
         public static explicit operator System.Numerics.Vector2(Vector2F<T> v) =>
             new(Convert.ToSingle(v.X), Convert.ToSingle(v.Y));
 
-        // Component Operators
-        public static Vector2F<T> operator +(Vector2F<T> left, Vector2F<T> right) =>
-            new(left.X + right.X, left.Y + right.Y);
-
-        public static Vector2F<T> operator -(Vector2F<T> left, Vector2F<T> right) =>
-            new(left.X - right.X, left.Y - right.Y);
-
-        public static Vector2F<T> operator *(Vector2F<T> left, Vector2F<T> right) =>
-            new(left.X * right.X, left.Y * right.Y);
-
-        public static Vector2F<T> operator /(Vector2F<T> left, Vector2F<T> right) =>
-            new(left.X / right.X, left.Y / right.Y);
-
-        public static Vector2F<T> operator %(Vector2F<T> left, Vector2F<T> right) =>
-            new(left.X % right.X, left.Y % right.Y);
-
-        // Scalar Operators
-        public static Vector2F<T> operator +(Vector2F<T> vector, T scalar) =>
-            new(vector.X + scalar, vector.Y + scalar);
-
-        public static Vector2F<T> operator -(Vector2F<T> vector, T scalar) =>
-            new(vector.X - scalar, vector.Y - scalar);
-
-        public static Vector2F<T> operator *(Vector2F<T> vector, T scalar) =>
-            new(vector.X * scalar, vector.Y * scalar);
-
-        public static Vector2F<T> operator /(Vector2F<T> vector, T scalar) =>
-            new(vector.X / scalar, vector.Y / scalar);
-
-        public static Vector2F<T> operator %(Vector2F<T> vector, T scalar) =>
-            new(vector.X % scalar, vector.Y % scalar);
-
-        // + operator: returns the vector
-        public static Vector2F<T> operator +(Vector2F<T> vector) => vector;
-
-        // - operator: returns the negated vector
-        public static Vector2F<T> operator -(Vector2F<T> vector) =>
-            new(-vector.X, -vector.Y);
-
         // IFloatingPointIeee754
         public static Vector2F<T> Sqrt(Vector2F<T> x) =>
             new(T.Sqrt(x.X), T.Sqrt(x.Y));
@@ -616,4 +312,11 @@ public static Vector2F<T> ScaleB(Vector2F<T> x, Vector2I<int> n) =>
         public static Vector2F<T> ScaleB(Vector2F<T> x, int n) =>
             new(T.ScaleB(x.X, n), T.ScaleB(x.Y, n));
     }
+
+    static partial class Vector2F
+    {
+        /// <summary> Computes the cross product of two vectors.</summary>
+        public static T Cross<T>(this Vector2F<T> left, Vector2F<T> right)
+            where T : IFloatingPointIeee754<T> => (left.X * right.Y) - (left.Y * right.X);
+    }
 }
diff --git a/sources/Maths/Maths/Vector2F.gen.cs b/sources/Maths/Maths/Vector2F.gen.cs
index 34d27f31f1..b7c5cfc47f 100644
--- a/sources/Maths/Maths/Vector2F.gen.cs
+++ b/sources/Maths/Maths/Vector2F.gen.cs
@@ -3,10 +3,18 @@ namespace Silk.NET.Maths
     using System.Collections;
     using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
+    using System.Runtime.InteropServices;
+    using System.Text;
 
     partial struct Vector2F<T> :
         IEquatable<Vector2F<T>>,
-        IReadOnlyList<T>
+        IReadOnlyList<T>,
+        IFormattable,
+        IParsable<Vector2F<T>>,
+        ISpanFormattable,
+        ISpanParsable<Vector2F<T>>,
+        IUtf8SpanFormattable,
+        IUtf8SpanParsable<Vector2F<T>>
         where T : IFloatingPointIeee754<T>
     {
         /// <summary>The X component of the vector.</summary>
@@ -21,6 +29,31 @@ partial struct Vector2F<T> :
         /// <summary>Initializes the vector with individual component values.</summary>
         public Vector2F(T x, T y) => (X, Y) = (x, y);
 
+        /// <summary>Initializes the vector from a span of 2 values.</summary>
+        public Vector2F(ReadOnlySpan<T> values)
+        {
+            if (values.Length != 2)
+                throw new ArgumentException("Input span must contain exactly 2 elements.", nameof(values));
+
+            X = values[0];
+            Y = values[1];
+        }
+
+        /// <summary>Gets a vector whose 2 elements are equal to one.</summary>
+        public static Vector2F<T> One => new(Scalar<T>.One);
+
+        /// <summary>Returns a vector whose 2 elements are equal to zero.</summary>
+        public static Vector2F<T> Zero => default;
+
+        /// <summary>Gets the vector (1, 0).</summary>
+        public static Vector2F<T> UnitX => new(Scalar<T>.One, Scalar<T>.Zero);
+
+        /// <summary>Gets the vector (0, 1).</summary>
+        public static Vector2F<T> UnitY => new(Scalar<T>.Zero, Scalar<T>.One);
+
+        /// <summary>Gets the squared length of the vector (dot product with itself).</summary>
+        public T LengthSquared => Vector2F.Dot(this, this);
+
         /// <inheritdoc/>
         T IReadOnlyList<T>.this[int index] => this[index];
 
@@ -55,6 +88,197 @@ public IEnumerator<T> GetEnumerator()
             yield return Y;
         }
 
+        /// <summary>Copies the components of the vector to the specified array starting at index 0.</summary>
+        public void CopyTo(T[] array) => CopyTo(array, 0);
+
+        /// <summary>Copies the components of the vector to the specified array starting at the given index.</summary>
+        public void CopyTo(T[] array, int startIndex)
+        {
+            if (array == null)
+                throw new ArgumentNullException(nameof(array));
+            if (startIndex < 0 || startIndex + 2 > array.Length)
+                throw new ArgumentOutOfRangeException(nameof(startIndex));
+
+            array[startIndex] = X;
+            array[startIndex + 1] = Y;
+        }
+
+        /// <summary>Copies the components of the vector to the specified span starting at index 0.</summary>
+        public void CopyTo(Span<T> span) => CopyTo(span, 0);
+
+        /// <summary>Copies the components of the vector to the specified span starting at the given index.</summary>
+        public void CopyTo(Span<T> span, int startIndex)
+        {
+            if (startIndex < 0 || startIndex + 2 > span.Length)
+                throw new ArgumentOutOfRangeException(nameof(startIndex));
+
+            span[startIndex] = X;
+            span[startIndex + 1] = Y;
+        }
+
+        /// <summary>Returns a span over the vector components.</summary>
+        public Span<T> AsSpan() => MemoryMarshal.CreateSpan(ref X, 2);
+
+        /// <summary>Formats the vector as a string.</summary>
+        public override string ToString() =>
+            $"<{X}, {Y}>";
+
+        /// <summary>Formats the vector as a string using the specified format and format provider.</summary>
+        public string ToString(string? format, IFormatProvider? formatProvider) =>
+            $"<{X.ToString(format, formatProvider)}, {Y.ToString(format, formatProvider)}>";
+
+        /// <summary>Parses a string to a <see cref="Vector2F{T}"/> instance.</summary>
+        public static Vector2F<T> Parse(string s, IFormatProvider? provider) => Parse(s.AsSpan(), provider);
+
+        /// <summary>Parses a span to a <see cref="Vector2F{T}"/> instance.</summary>
+        public static Vector2F<T> Parse(ReadOnlySpan<char> s, IFormatProvider? provider)
+        {
+            if (!TryParse(s, provider, out var result))
+                throw new FormatException("Invalid format for Vector2F.");
+
+            return result;
+        }
+
+        /// <summary>Formats the vector as a UTF-8 string using the specified format and format provider.</summary>
+        public bool TryFormat(Span<byte> utf8Destination, out int bytesWritten, ReadOnlySpan<char> format, IFormatProvider? provider)
+        {
+            Span<char> xBuffer = stackalloc char[64];
+            Span<char> yBuffer = stackalloc char[64];
+
+            if (!X.TryFormat(xBuffer, out int xChars, format, provider)||
+                !Y.TryFormat(yBuffer, out int yChars, format, provider))
+            {
+                bytesWritten = 0;
+                return false;
+            }
+
+            int estimatedSize = Encoding.UTF8.GetByteCount(xBuffer[..xChars]) +
+                                Encoding.UTF8.GetByteCount(yBuffer[..yChars]) +
+                                Encoding.UTF8.GetByteCount("<, >");
+
+            if (utf8Destination.Length < estimatedSize)
+            {
+                bytesWritten = 0;
+                return false;
+            }
+
+            int totalBytes = 0;
+
+            totalBytes += Encoding.UTF8.GetBytes("<", utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(xBuffer[..xChars], utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(", ", utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(yBuffer[..yChars], utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(">", utf8Destination[totalBytes..]);
+
+            bytesWritten = totalBytes;
+            return true;
+        }
+
+        /// <summary>Formats the vector as a string using the specified format and format provider.</summary>
+        public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format, IFormatProvider? provider)
+        {
+            Span<char> xBuffer = stackalloc char[64];
+            Span<char> yBuffer = stackalloc char[64];
+
+            if (!X.TryFormat(xBuffer, out int xChars, format, provider) ||
+                !Y.TryFormat(yBuffer, out int yChars, format, provider))
+            {
+                charsWritten = 0;
+                return false;
+            }
+
+            int requiredLength = 1 + xChars + 2 + yChars + 1;
+
+            if (destination.Length < requiredLength)
+            {
+                charsWritten = 0;
+                return false;
+            }
+
+            int pos = 0;
+            destination[pos++] = '<';
+
+            xBuffer[..xChars].CopyTo(destination[pos..]);
+            pos += xChars;
+
+            destination[pos++] = ',';
+            destination[pos++] = ' ';
+
+            yBuffer[..yChars].CopyTo(destination[pos..]);
+            pos += yChars;
+
+            destination[pos++] = '>';
+
+            charsWritten = pos;
+            return true;
+        }
+
+        /// <summary>Tries to parse a span to a <see cref="Vector2F{T}"/> instance.</summary>
+        public static bool TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector2F<T> result)
+        {
+            result = default;
+
+            s = s.Trim();
+            if (s.Length < 4 || s[0] != '<' || s[^1] != '>')
+                return false;
+
+            s = s[1..^1]; // Remove < and >
+
+            int commaX = s.IndexOf(',');
+            if (commaX < 0)
+                return false;
+
+            ReadOnlySpan<char> xSpan = s[..commaX].Trim();
+            ReadOnlySpan<char> ySpan = s[(commaX + 1)..].Trim();
+
+            if (T.TryParse(xSpan, provider, out var x) &&
+                T.TryParse(ySpan, provider, out var y))
+            {
+                result = new Vector2F<T>(x, y);
+                return true;
+            }
+
+            return false;
+        }
+
+        /// <summary>Parses a UTF-8 span to a <see cref="Vector2F{T}"/> instance.</summary>
+        public static Vector2F<T> Parse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider)
+        {
+            int charCount = Encoding.UTF8.GetCharCount(utf8Text);
+            Span<char> charBuffer = charCount <= 128 ? stackalloc char[charCount] : new char[charCount];
+            Encoding.UTF8.GetChars(utf8Text, charBuffer);
+            return Parse(charBuffer, provider);
+        }
+
+        /// <summary>Tries to parse a UTF-8 span to a <see cref="Vector2F{T}"/> instance.</summary>
+        public static bool TryParse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector2F<T> result)
+        {
+            int charCount = Encoding.UTF8.GetCharCount(utf8Text);
+            Span<char> charBuffer = charCount <= 128 ? stackalloc char[charCount] : new char[charCount];
+            Encoding.UTF8.GetChars(utf8Text, charBuffer);
+            return TryParse(charBuffer, provider, out result);
+        }
+
+        /// <summary>Tries to parse a string to a <see cref="Vector2F{T}"/> instance.</summary>
+        public static bool TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector2F<T> result) =>
+            TryParse(s.AsSpan(), provider, out result);
+
+        /// <summary>Parses a span to a <see cref="Vector2F{T}"/> instance.</summary>
+        static Vector2F<T> ISpanParsable<Vector2F<T>>.Parse(ReadOnlySpan<char> s, IFormatProvider? provider) =>
+            Parse(s, provider);
+
+        /// <summary>Parses a string to a <see cref="Vector2F{T}"/> instance.</summary>
+        static Vector2F<T> IParsable<Vector2F<T>>.Parse(string s, IFormatProvider? provider) =>
+            Parse(s, provider);
+
+        /// <summary>Tries to parse a span to a <see cref="Vector2F{T}"/> instance.</summary>
+        static bool ISpanParsable<Vector2F<T>>.TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector2F<T> result) =>
+            TryParse(s, provider, out result);
+
+        /// <summary>Tries to parse a string to a <see cref="Vector2F{T}"/> instance.</summary>
+        static bool IParsable<Vector2F<T>>.TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector2F<T> result) =>
+            TryParse(s, provider, out result);
+
         /// <summary>Returns a boolean indicating whether the given two vectors are equal.</summary>
         /// <param name="left">The first vector to compare.</param>
         /// <param name="right">The second vector to compare.</param>
@@ -77,10 +301,76 @@ public IEnumerator<T> GetEnumerator()
 
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(X, Y);
+
+        public static Vector2F<T> operator +(Vector2F<T> vector) =>
+            vector;
+
+        public static Vector2F<T> operator -(Vector2F<T> vector) =>
+            new Vector2F<T>(-vector.X, -vector.Y);
+
+        public static Vector2F<T> operator +(Vector2F<T> left, Vector2F<T> right) =>
+            new Vector2F<T>(left.X + right.X, left.Y + right.Y);
+
+        public static Vector2F<T> operator -(Vector2F<T> left, Vector2F<T> right) =>
+            new Vector2F<T>(left.X - right.X, left.Y - right.Y);
+
+        public static Vector2F<T> operator *(Vector2F<T> left, Vector2F<T> right) =>
+            new Vector2F<T>(left.X * right.X, left.Y * right.Y);
+
+        public static Vector2F<T> operator /(Vector2F<T> left, Vector2F<T> right) =>
+            new Vector2F<T>(left.X / right.X, left.Y / right.Y);
+
+        public static Vector2F<T> operator %(Vector2F<T> left, Vector2F<T> right) =>
+            new Vector2F<T>(left.X % right.X, left.Y % right.Y);
+
+        public static Vector2F<T> operator +(Vector2F<T> vector, T scalar) =>
+            new Vector2F<T>(vector.X + scalar, vector.Y + scalar);
+
+        public static Vector2F<T> operator -(Vector2F<T> vector, T scalar) =>
+            new Vector2F<T>(vector.X - scalar, vector.Y - scalar);
+
+        public static Vector2F<T> operator *(Vector2F<T> vector, T scalar) =>
+            new Vector2F<T>(vector.X * scalar, vector.Y * scalar);
+
+        public static Vector2F<T> operator *(T scalar, Vector2F<T> vector) =>
+            new Vector2F<T>(scalar * vector.X, scalar * vector.Y);
+
+        public static Vector2F<T> operator /(Vector2F<T> vector, T scalar) =>
+            new Vector2F<T>(vector.X / scalar, vector.Y / scalar);
+
+        public static Vector2F<T> operator %(Vector2F<T> vector, T scalar) =>
+            new Vector2F<T>(vector.X % scalar, vector.Y % scalar);
+
     }
 
     static partial class Vector2F
     {
+        /// <summary>Computes the dot product of two vectors.</summary>
+        public static T Dot<T>(this Vector2F<T> left, Vector2F<T> right)
+            where T : IFloatingPointIeee754<T> =>
+            left.X * right.X + left.Y * right.Y;
+
+        /// <summary>Reflects a vector over a normal vector.</summary>
+        public static Vector2F<T> Reflect<T>(Vector2F<T> vector, Vector2F<T> normal)
+            where T : IFloatingPointIeee754<T>
+        {
+            T dot = vector.Dot(normal);
+            return vector - (normal * (dot + dot));
+        }
+
+        /// <summary>Computes the length of the vector.</summary>
+        public static T GetLength<T>(this Vector2F<T> vector)
+            where T : IFloatingPointIeee754<T> =>
+            T.Sqrt(vector.LengthSquared);
+
+        /// <summary>Normalizes a vector.</summary>
+        public static Vector2F<T> Normalize<T>(this Vector2F<T> vector)
+            where T : IFloatingPointIeee754<T>
+        {
+            T length = vector.GetLength();
+            return length != T.Zero ? vector / length : Vector2F<T>.Zero;
+        }
+
         public static Vector2F<TSelf> Log<TSelf>(this Vector2F<TSelf> x)
             where TSelf : IFloatingPointIeee754<TSelf>, ILogarithmicFunctions<TSelf> =>
             new(TSelf.Log(x.X), TSelf.Log(x.Y));
diff --git a/sources/Maths/Maths/Vector2I.cs b/sources/Maths/Maths/Vector2I.cs
index 2a49a846b5..fceb7b5b44 100644
--- a/sources/Maths/Maths/Vector2I.cs
+++ b/sources/Maths/Maths/Vector2I.cs
@@ -12,58 +12,14 @@
 namespace Silk.NET.Maths
 {
     /// <summary>A structure representing a 2D integer vector.</summary>
-    internal partial struct Vector2I<T> :
-        ISpanFormattable,
-        ISpanParsable<Vector2I<T>>,
-        IUtf8SpanFormattable,
-        IUtf8SpanParsable<Vector2I<T>>,
-        IParsable<Vector2I<T>>,
-        IFormattable
-        where T : IBinaryInteger<T>
+    internal partial struct Vector2I<T>
     {
-        /// <summary>Initializes the vector from a span of two values.</summary>
-        public Vector2I(ReadOnlySpan<T> values)
-        {
-            if (values.Length != 2)
-                throw new ArgumentException("Input span must contain exactly 2 elements.", nameof(values));
-
-            X = values[0];
-            Y = values[1];
-        }
-
-        /// <summary>Gets a vector whose 2 elements are equal to one.</summary>
-        public static Vector2I<T> One => new(Scalar<T>.One);
-
-        /// <summary>Returns a vector whose 2 elements are equal to zero.</summary>
-        public static Vector2I<T> Zero => default;
-
-        /// <summary>Gets the vector (1, 0).</summary>
-        public static Vector2I<T> UnitX => new(Scalar<T>.One, Scalar<T>.Zero);
-
-        /// <summary>Gets the vector (0, 1).</summary>
-        public static Vector2I<T> UnitY => new(Scalar<T>.Zero, Scalar<T>.One);
-
-        /// <summary>Gets a vector with all bits set for each component.</summary>
-        public static Vector2I<T> AllBitsSet => new Vector2I<T>(T.AllBitsSet, T.AllBitsSet);
-
-        /// <summary>Gets the squared length of the vector (dot product with itself).</summary>
-        public T LengthSquared => (X * X) + (Y * Y);
-
-        /// <summary> Computes the dot product of this vector with another vector. </summary>
-        public T Dot(Vector2I<T> other) => (X * other.X) + (Y * other.Y);
-
-        /// <summary> Computes the dot product of two vectors. </summary>
-        public static T Dot(Vector2I<T> left, Vector2I<T> right) => (left.X * right.X) + (left.Y * right.Y);
-
         /// <summary> Computes the cross product of this vector with another vector. </summary>
         public T Cross(Vector2I<T> other) => (X * other.Y) - (Y * other.X);
 
         /// <summary> Computes the cross product of two vectors. </summary>
         public static T Cross(Vector2I<T> left, Vector2I<T> right) => (left.X * right.Y) - (left.Y * right.X);
 
-        /// <summary>Returns a span over the vector components.</summary>
-        public Span<T> AsSpan() => MemoryMarshal.CreateSpan(ref X, 2);
-
         /// <summary>Returns a vector with the component-wise maximum of this and another vector.</summary>
         public Vector2I<T> Max(Vector2I<T> other) =>
             new Vector2I<T>(T.Max(X, other.X), T.Max(Y, other.Y));
@@ -119,90 +75,6 @@ public static Vector2I<T> Clamp(Vector2I<T> vector, T min, T max) =>
         public static Vector2I<T> Abs(Vector2I<T> vector) =>
             new Vector2I<T>(T.Abs(vector.X), T.Abs(vector.Y));
 
-        /// <summary>Formats the vector as a string using the specified format and format provider.</summary>
-        public string ToString(string? format, IFormatProvider? formatProvider) => $"<{X.ToString(format, formatProvider)}, {Y.ToString(format, formatProvider)}>";
-
-        /// <summary>Formats the vector as a string.</summary>
-        public override string ToString() => $"<{X}, {Y}>";
-
-        /// <summary>Formats the vector as a string using the specified format and format provider.</summary>
-        public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format, IFormatProvider? provider)
-        {
-            // Format components individually into temporary buffers
-            // Not too sure about this implementation
-            Span<char> xBuffer = stackalloc char[64];
-            Span<char> yBuffer = stackalloc char[64];
-
-            if (!X.TryFormat(xBuffer, out int xChars, format, provider) ||
-                !Y.TryFormat(yBuffer, out int yChars, format, provider))
-            {
-                charsWritten = 0;
-                return false;
-            }
-
-            // Calculate total required length: < + x + ", " + y + >
-            int requiredLength = 1 + xChars + 2 + yChars + 1;
-
-            if (destination.Length < requiredLength)
-            {
-                charsWritten = 0;
-                return false;
-            }
-
-            int pos = 0;
-            destination[pos++] = '<';
-
-            xBuffer[..xChars].CopyTo(destination[pos..]);
-            pos += xChars;
-
-            destination[pos++] = ',';
-            destination[pos++] = ' ';
-
-            yBuffer[..yChars].CopyTo(destination[pos..]);
-            pos += yChars;
-
-            destination[pos++] = '>';
-
-            charsWritten = pos;
-            return true;
-        }
-
-        /// <summary>Parses a span to a <see cref="Vector2I{T}"/> instance.</summary>
-        public static Vector2I<T> Parse(ReadOnlySpan<char> s, IFormatProvider? provider)
-        {
-            if (!TryParse(s, provider, out var result))
-                throw new FormatException("Invalid format for Vector2I.");
-
-            return result;
-        }
-
-        /// <summary>Copies the components of the vector to the specified array starting at index 0.</summary>
-        public void CopyTo(T[] array) => CopyTo(array, 0);
-
-        /// <summary>Copies the components of the vector to the specified array starting at the given index.</summary>
-        public void CopyTo(T[] array, int startIndex)
-        {
-            if (array == null)
-                throw new ArgumentNullException(nameof(array));
-            if (startIndex < 0 || startIndex + 2 > array.Length)
-                throw new ArgumentOutOfRangeException(nameof(startIndex));
-            array[startIndex] = X;
-            array[startIndex + 1] = Y;
-        }
-
-        /// <summary>Copies the components of the vector to the specified span starting at index 0.</summary>
-        public void CopyTo(Span<T> span) => CopyTo(span, 0);
-
-        /// <summary>Copies the components of the vector to the specified span starting at the given index.</summary>
-        public void CopyTo(Span<T> span, int startIndex)
-        {
-            if (startIndex < 0 || startIndex + 2 > span.Length)
-                throw new ArgumentOutOfRangeException(nameof(startIndex));
-
-            span[startIndex] = X;
-            span[startIndex + 1] = Y;
-        }
-
         /// <summary>Returns a vector where each component is the sign of the original vector's component.</summary>
         public Vector2I<T> Sign() => new Vector2I<T>(T.CreateChecked(T.Sign(X)), T.CreateChecked(T.Sign(Y)));
 
@@ -226,114 +98,6 @@ public Vector2I<T> CopySign(T signScalar) =>
         public static Vector2I<T> CopySign(Vector2I<T> value, T signScalar) =>
             new Vector2I<T>(T.CopySign(value.X, signScalar), T.CopySign(value.Y, signScalar));
 
-        /// <summary>Parses a string to a <see cref="Vector2I{T}"/> instance.</summary>
-        public static Vector2I<T> Parse(string s, IFormatProvider? provider) => Parse(s.AsSpan(), provider);
-
-        /// <summary>Tries to parse a span to a <see cref="Vector2I{T}"/> instance.</summary>
-        public static bool TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector2I<T> result)
-        {
-            result = default;
-
-            s = s.Trim();
-            if (s.Length < 5 || s[0] != '<' || s[^1] != '>')
-                return false;
-
-            s = s[1..^1]; // Remove < and >
-
-            int commaIndex = s.IndexOf(',');
-            if (commaIndex < 0)
-                return false;
-
-            ReadOnlySpan<char> xSpan = s[..commaIndex].Trim();
-            ReadOnlySpan<char> ySpan = s[(commaIndex + 1)..].Trim();
-
-            if (T.TryParse(xSpan, provider, out var x) &&
-                T.TryParse(ySpan, provider, out var y))
-            {
-                result = new Vector2I<T>(x, y);
-                return true;
-            }
-
-            return false;
-        }
-
-
-        /// <summary>Tries to parse a string to a <see cref="Vector2I{T}"/> instance.</summary>
-        public static bool TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector2I<T> result) =>
-            TryParse(s.AsSpan(), provider, out result);
-
-        /// <summary>Parses a span to a <see cref="Vector2I{T}"/> instance.</summary>
-        static Vector2I<T> ISpanParsable<Vector2I<T>>.Parse(ReadOnlySpan<char> s, IFormatProvider? provider) =>
-            Parse(s, provider);
-
-        /// <summary>Parses a string to a <see cref="Vector2I{T}"/> instance.</summary>
-        static Vector2I<T> IParsable<Vector2I<T>>.Parse(string s, IFormatProvider? provider) =>
-            Parse(s, provider);
-
-        /// <summary>Tries to parse a span to a <see cref="Vector2I{T}"/> instance.</summary>
-        static bool ISpanParsable<Vector2I<T>>.TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector2I<T> result) =>
-            TryParse(s, provider, out result);
-
-        /// <summary>Tries to parse a string to a <see cref="Vector2I{T}"/> instance.</summary>
-        static bool IParsable<Vector2I<T>>.TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector2I<T> result) =>
-            TryParse(s, provider, out result);
-
-        /// <summary>Formats the vector as a UTF-8 string using the specified format and format provider.</summary>
-        public bool TryFormat(Span<byte> utf8Destination, out int bytesWritten, ReadOnlySpan<char> format, IFormatProvider? provider)
-        {
-            // Format components individually into temporary buffers
-            // Not too sure about this implementation
-            Span<char> xBuffer = stackalloc char[64];
-            Span<char> yBuffer = stackalloc char[64];
-
-            if (!X.TryFormat(xBuffer, out int xChars, format, provider) ||
-                !Y.TryFormat(yBuffer, out int yChars, format, provider))
-            {
-                bytesWritten = 0;
-                return false;
-            }
-
-            // Estimate total required UTF-8 bytes
-            int estimatedSize = Encoding.UTF8.GetByteCount(xBuffer[..xChars]) +
-                                Encoding.UTF8.GetByteCount(yBuffer[..yChars]) +
-                                Encoding.UTF8.GetByteCount("<, >");
-
-            if (utf8Destination.Length < estimatedSize)
-            {
-                bytesWritten = 0;
-                return false;
-            }
-
-            int totalBytes = 0;
-
-            totalBytes += Encoding.UTF8.GetBytes("<", utf8Destination[totalBytes..]);
-            totalBytes += Encoding.UTF8.GetBytes(xBuffer[..xChars], utf8Destination[totalBytes..]);
-            totalBytes += Encoding.UTF8.GetBytes(", ", utf8Destination[totalBytes..]);
-            totalBytes += Encoding.UTF8.GetBytes(yBuffer[..yChars], utf8Destination[totalBytes..]);
-            totalBytes += Encoding.UTF8.GetBytes(">", utf8Destination[totalBytes..]);
-
-            bytesWritten = totalBytes;
-            return true;
-        }
-
-        /// <summary>Parses a UTF-8 span to a <see cref="Vector2I{T}"/> instance.</summary>
-        public static Vector2I<T> Parse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider)
-        {
-            int charCount = Encoding.UTF8.GetCharCount(utf8Text);
-            Span<char> charBuffer = charCount <= 128 ? stackalloc char[charCount] : new char[charCount];
-            Encoding.UTF8.GetChars(utf8Text, charBuffer);
-            return Parse(charBuffer, provider);
-        }
-
-        /// <summary>Tries to parse a UTF-8 span to a <see cref="Vector2I{T}"/> instance.</summary>
-        public static bool TryParse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector2I<T> result)
-        {
-            int charCount = Encoding.UTF8.GetCharCount(utf8Text);
-            Span<char> charBuffer = charCount <= 128 ? stackalloc char[charCount] : new char[charCount];
-            Encoding.UTF8.GetChars(utf8Text, charBuffer);
-            return TryParse(charBuffer, provider, out result);
-        }
-
         // Casts
 
         /// <summary>Explicitly casts a <see cref="System.Numerics.Vector2"/> to a <see cref="Vector2I{T}"/>.</summary>
@@ -344,77 +108,6 @@ public static explicit operator Vector2I<T>(System.Numerics.Vector2 v) =>
         public static explicit operator System.Numerics.Vector2(Vector2I<T> v) =>
             new System.Numerics.Vector2(Convert.ToSingle(v.X), Convert.ToSingle(v.Y));
 
-        // Component Operators
-        public static Vector2I<T> operator +(Vector2I<T> left, Vector2I<T> right) =>
-            new Vector2I<T>(left.X + right.X, left.Y + right.Y);
-
-        public static Vector2I<T> operator -(Vector2I<T> left, Vector2I<T> right) =>
-            new Vector2I<T>(left.X - right.X, left.Y - right.Y);
-
-        public static Vector2I<T> operator *(Vector2I<T> left, Vector2I<T> right) =>
-            new Vector2I<T>(left.X * right.X, left.Y * right.Y);
-
-        public static Vector2I<T> operator /(Vector2I<T> left, Vector2I<T> right) =>
-            new Vector2I<T>(left.X / right.X, left.Y / right.Y);
-
-        public static Vector2I<T> operator %(Vector2I<T> left, Vector2I<T> right) =>
-            new Vector2I<T>(left.X % right.X, left.Y % right.Y);
-
-        // Scalar Operators
-        public static Vector2I<T> operator +(Vector2I<T> vector, T scalar) =>
-            new Vector2I<T>(vector.X + scalar, vector.Y + scalar);
-
-        public static Vector2I<T> operator -(Vector2I<T> vector, T scalar) =>
-            new Vector2I<T>(vector.X - scalar, vector.Y - scalar);
-
-        public static Vector2I<T> operator *(Vector2I<T> vector, T scalar) =>
-            new Vector2I<T>(vector.X * scalar, vector.Y * scalar);
-
-        public static Vector2I<T> operator /(Vector2I<T> vector, T scalar) =>
-            new Vector2I<T>(vector.X / scalar, vector.Y / scalar);
-
-        public static Vector2I<T> operator %(Vector2I<T> vector, T scalar) =>
-            new Vector2I<T>(vector.X % scalar, vector.Y % scalar);
-
-        // + operator: returns the vector (?)
-        public static Vector2I<T> operator +(Vector2I<T> vector) => vector;
-
-        //  - operator: returns the negated vector
-        public static Vector2I<T> operator -(Vector2I<T> vector) =>
-            new Vector2I<T>(-vector.X, -vector.Y);
-
-        // Bitwise Operators
-        public static Vector2I<T> operator &(Vector2I<T> left, Vector2I<T> right) =>
-            new Vector2I<T>(left.X & right.X, left.Y & right.Y);
-
-        public static Vector2I<T> operator |(Vector2I<T> left, Vector2I<T> right) =>
-            new Vector2I<T>(left.X | right.X, left.Y | right.Y);
-
-        public static Vector2I<T> operator ^(Vector2I<T> left, Vector2I<T> right) =>
-            new Vector2I<T>(left.X ^ right.X, left.Y ^ right.Y);
-
-        public static Vector2I<T> operator &(Vector2I<T> vector, T scalar) =>
-            new Vector2I<T>(vector.X & scalar, vector.Y & scalar);
-
-        public static Vector2I<T> operator &(T scalar, Vector2I<T> vector) =>
-            new Vector2I<T>(scalar & vector.X, scalar & vector.Y);
-
-        public static Vector2I<T> operator |(Vector2I<T> vector, T scalar) =>
-            new Vector2I<T>(vector.X | scalar, vector.Y | scalar);
-
-        public static Vector2I<T> operator |(T scalar, Vector2I<T> vector) =>
-            new Vector2I<T>(scalar | vector.X, scalar | vector.Y);
-
-        public static Vector2I<T> operator ^(Vector2I<T> vector, T scalar) =>
-            new Vector2I<T>(vector.X ^ scalar, vector.Y ^ scalar);
-
-        public static Vector2I<T> operator ^(T scalar, Vector2I<T> vector) =>
-            new Vector2I<T>(scalar ^ vector.X, scalar ^ vector.Y);
-
-        // NOT operator
-        public static Vector2I<T> operator ~(Vector2I<T> vector) =>
-            new Vector2I<T>(~vector.X, ~vector.Y);
-
         // IBinaryInteger
         // TODO: Verify these are actually correct
 
diff --git a/sources/Maths/Maths/Vector2I.gen.cs b/sources/Maths/Maths/Vector2I.gen.cs
index c8631934e7..afe221d779 100644
--- a/sources/Maths/Maths/Vector2I.gen.cs
+++ b/sources/Maths/Maths/Vector2I.gen.cs
@@ -3,10 +3,18 @@ namespace Silk.NET.Maths
     using System.Collections;
     using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
+    using System.Runtime.InteropServices;
+    using System.Text;
 
     partial struct Vector2I<T> :
         IEquatable<Vector2I<T>>,
-        IReadOnlyList<T>
+        IReadOnlyList<T>,
+        IFormattable,
+        IParsable<Vector2I<T>>,
+        ISpanFormattable,
+        ISpanParsable<Vector2I<T>>,
+        IUtf8SpanFormattable,
+        IUtf8SpanParsable<Vector2I<T>>
         where T : IBinaryInteger<T>
     {
         /// <summary>The X component of the vector.</summary>
@@ -21,6 +29,34 @@ partial struct Vector2I<T> :
         /// <summary>Initializes the vector with individual component values.</summary>
         public Vector2I(T x, T y) => (X, Y) = (x, y);
 
+        /// <summary>Initializes the vector from a span of 2 values.</summary>
+        public Vector2I(ReadOnlySpan<T> values)
+        {
+            if (values.Length != 2)
+                throw new ArgumentException("Input span must contain exactly 2 elements.", nameof(values));
+
+            X = values[0];
+            Y = values[1];
+        }
+
+        /// <summary>Gets a vector whose 2 elements are equal to one.</summary>
+        public static Vector2I<T> One => new(Scalar<T>.One);
+
+        /// <summary>Returns a vector whose 2 elements are equal to zero.</summary>
+        public static Vector2I<T> Zero => default;
+
+        /// <summary>Gets the vector (1, 0).</summary>
+        public static Vector2I<T> UnitX => new(Scalar<T>.One, Scalar<T>.Zero);
+
+        /// <summary>Gets the vector (0, 1).</summary>
+        public static Vector2I<T> UnitY => new(Scalar<T>.Zero, Scalar<T>.One);
+
+        /// <summary>Gets a vector with all bits set for each component.</summary>
+        public static Vector2I<T> AllBitsSet => new Vector2I<T>(T.AllBitsSet, T.AllBitsSet);
+
+        /// <summary>Gets the squared length of the vector (dot product with itself).</summary>
+        public T LengthSquared => Vector2I.Dot(this, this);
+
         /// <inheritdoc/>
         T IReadOnlyList<T>.this[int index] => this[index];
 
@@ -55,6 +91,197 @@ public IEnumerator<T> GetEnumerator()
             yield return Y;
         }
 
+        /// <summary>Copies the components of the vector to the specified array starting at index 0.</summary>
+        public void CopyTo(T[] array) => CopyTo(array, 0);
+
+        /// <summary>Copies the components of the vector to the specified array starting at the given index.</summary>
+        public void CopyTo(T[] array, int startIndex)
+        {
+            if (array == null)
+                throw new ArgumentNullException(nameof(array));
+            if (startIndex < 0 || startIndex + 2 > array.Length)
+                throw new ArgumentOutOfRangeException(nameof(startIndex));
+
+            array[startIndex] = X;
+            array[startIndex + 1] = Y;
+        }
+
+        /// <summary>Copies the components of the vector to the specified span starting at index 0.</summary>
+        public void CopyTo(Span<T> span) => CopyTo(span, 0);
+
+        /// <summary>Copies the components of the vector to the specified span starting at the given index.</summary>
+        public void CopyTo(Span<T> span, int startIndex)
+        {
+            if (startIndex < 0 || startIndex + 2 > span.Length)
+                throw new ArgumentOutOfRangeException(nameof(startIndex));
+
+            span[startIndex] = X;
+            span[startIndex + 1] = Y;
+        }
+
+        /// <summary>Returns a span over the vector components.</summary>
+        public Span<T> AsSpan() => MemoryMarshal.CreateSpan(ref X, 2);
+
+        /// <summary>Formats the vector as a string.</summary>
+        public override string ToString() =>
+            $"<{X}, {Y}>";
+
+        /// <summary>Formats the vector as a string using the specified format and format provider.</summary>
+        public string ToString(string? format, IFormatProvider? formatProvider) =>
+            $"<{X.ToString(format, formatProvider)}, {Y.ToString(format, formatProvider)}>";
+
+        /// <summary>Parses a string to a <see cref="Vector2I{T}"/> instance.</summary>
+        public static Vector2I<T> Parse(string s, IFormatProvider? provider) => Parse(s.AsSpan(), provider);
+
+        /// <summary>Parses a span to a <see cref="Vector2I{T}"/> instance.</summary>
+        public static Vector2I<T> Parse(ReadOnlySpan<char> s, IFormatProvider? provider)
+        {
+            if (!TryParse(s, provider, out var result))
+                throw new FormatException("Invalid format for Vector2I.");
+
+            return result;
+        }
+
+        /// <summary>Formats the vector as a UTF-8 string using the specified format and format provider.</summary>
+        public bool TryFormat(Span<byte> utf8Destination, out int bytesWritten, ReadOnlySpan<char> format, IFormatProvider? provider)
+        {
+            Span<char> xBuffer = stackalloc char[64];
+            Span<char> yBuffer = stackalloc char[64];
+
+            if (!X.TryFormat(xBuffer, out int xChars, format, provider)||
+                !Y.TryFormat(yBuffer, out int yChars, format, provider))
+            {
+                bytesWritten = 0;
+                return false;
+            }
+
+            int estimatedSize = Encoding.UTF8.GetByteCount(xBuffer[..xChars]) +
+                                Encoding.UTF8.GetByteCount(yBuffer[..yChars]) +
+                                Encoding.UTF8.GetByteCount("<, >");
+
+            if (utf8Destination.Length < estimatedSize)
+            {
+                bytesWritten = 0;
+                return false;
+            }
+
+            int totalBytes = 0;
+
+            totalBytes += Encoding.UTF8.GetBytes("<", utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(xBuffer[..xChars], utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(", ", utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(yBuffer[..yChars], utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(">", utf8Destination[totalBytes..]);
+
+            bytesWritten = totalBytes;
+            return true;
+        }
+
+        /// <summary>Formats the vector as a string using the specified format and format provider.</summary>
+        public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format, IFormatProvider? provider)
+        {
+            Span<char> xBuffer = stackalloc char[64];
+            Span<char> yBuffer = stackalloc char[64];
+
+            if (!X.TryFormat(xBuffer, out int xChars, format, provider) ||
+                !Y.TryFormat(yBuffer, out int yChars, format, provider))
+            {
+                charsWritten = 0;
+                return false;
+            }
+
+            int requiredLength = 1 + xChars + 2 + yChars + 1;
+
+            if (destination.Length < requiredLength)
+            {
+                charsWritten = 0;
+                return false;
+            }
+
+            int pos = 0;
+            destination[pos++] = '<';
+
+            xBuffer[..xChars].CopyTo(destination[pos..]);
+            pos += xChars;
+
+            destination[pos++] = ',';
+            destination[pos++] = ' ';
+
+            yBuffer[..yChars].CopyTo(destination[pos..]);
+            pos += yChars;
+
+            destination[pos++] = '>';
+
+            charsWritten = pos;
+            return true;
+        }
+
+        /// <summary>Tries to parse a span to a <see cref="Vector2I{T}"/> instance.</summary>
+        public static bool TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector2I<T> result)
+        {
+            result = default;
+
+            s = s.Trim();
+            if (s.Length < 4 || s[0] != '<' || s[^1] != '>')
+                return false;
+
+            s = s[1..^1]; // Remove < and >
+
+            int commaX = s.IndexOf(',');
+            if (commaX < 0)
+                return false;
+
+            ReadOnlySpan<char> xSpan = s[..commaX].Trim();
+            ReadOnlySpan<char> ySpan = s[(commaX + 1)..].Trim();
+
+            if (T.TryParse(xSpan, provider, out var x) &&
+                T.TryParse(ySpan, provider, out var y))
+            {
+                result = new Vector2I<T>(x, y);
+                return true;
+            }
+
+            return false;
+        }
+
+        /// <summary>Parses a UTF-8 span to a <see cref="Vector2I{T}"/> instance.</summary>
+        public static Vector2I<T> Parse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider)
+        {
+            int charCount = Encoding.UTF8.GetCharCount(utf8Text);
+            Span<char> charBuffer = charCount <= 128 ? stackalloc char[charCount] : new char[charCount];
+            Encoding.UTF8.GetChars(utf8Text, charBuffer);
+            return Parse(charBuffer, provider);
+        }
+
+        /// <summary>Tries to parse a UTF-8 span to a <see cref="Vector2I{T}"/> instance.</summary>
+        public static bool TryParse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector2I<T> result)
+        {
+            int charCount = Encoding.UTF8.GetCharCount(utf8Text);
+            Span<char> charBuffer = charCount <= 128 ? stackalloc char[charCount] : new char[charCount];
+            Encoding.UTF8.GetChars(utf8Text, charBuffer);
+            return TryParse(charBuffer, provider, out result);
+        }
+
+        /// <summary>Tries to parse a string to a <see cref="Vector2I{T}"/> instance.</summary>
+        public static bool TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector2I<T> result) =>
+            TryParse(s.AsSpan(), provider, out result);
+
+        /// <summary>Parses a span to a <see cref="Vector2I{T}"/> instance.</summary>
+        static Vector2I<T> ISpanParsable<Vector2I<T>>.Parse(ReadOnlySpan<char> s, IFormatProvider? provider) =>
+            Parse(s, provider);
+
+        /// <summary>Parses a string to a <see cref="Vector2I{T}"/> instance.</summary>
+        static Vector2I<T> IParsable<Vector2I<T>>.Parse(string s, IFormatProvider? provider) =>
+            Parse(s, provider);
+
+        /// <summary>Tries to parse a span to a <see cref="Vector2I{T}"/> instance.</summary>
+        static bool ISpanParsable<Vector2I<T>>.TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector2I<T> result) =>
+            TryParse(s, provider, out result);
+
+        /// <summary>Tries to parse a string to a <see cref="Vector2I{T}"/> instance.</summary>
+        static bool IParsable<Vector2I<T>>.TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector2I<T> result) =>
+            TryParse(s, provider, out result);
+
         /// <summary>Returns a boolean indicating whether the given two vectors are equal.</summary>
         /// <param name="left">The first vector to compare.</param>
         /// <param name="right">The second vector to compare.</param>
@@ -77,10 +304,92 @@ public IEnumerator<T> GetEnumerator()
 
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(X, Y);
+
+        public static Vector2I<T> operator +(Vector2I<T> vector) =>
+            vector;
+
+        public static Vector2I<T> operator -(Vector2I<T> vector) =>
+            new Vector2I<T>(-vector.X, -vector.Y);
+
+        public static Vector2I<T> operator +(Vector2I<T> left, Vector2I<T> right) =>
+            new Vector2I<T>(left.X + right.X, left.Y + right.Y);
+
+        public static Vector2I<T> operator -(Vector2I<T> left, Vector2I<T> right) =>
+            new Vector2I<T>(left.X - right.X, left.Y - right.Y);
+
+        public static Vector2I<T> operator *(Vector2I<T> left, Vector2I<T> right) =>
+            new Vector2I<T>(left.X * right.X, left.Y * right.Y);
+
+        public static Vector2I<T> operator /(Vector2I<T> left, Vector2I<T> right) =>
+            new Vector2I<T>(left.X / right.X, left.Y / right.Y);
+
+        public static Vector2I<T> operator %(Vector2I<T> left, Vector2I<T> right) =>
+            new Vector2I<T>(left.X % right.X, left.Y % right.Y);
+
+        public static Vector2I<T> operator +(Vector2I<T> vector, T scalar) =>
+            new Vector2I<T>(vector.X + scalar, vector.Y + scalar);
+
+        public static Vector2I<T> operator -(Vector2I<T> vector, T scalar) =>
+            new Vector2I<T>(vector.X - scalar, vector.Y - scalar);
+
+        public static Vector2I<T> operator *(Vector2I<T> vector, T scalar) =>
+            new Vector2I<T>(vector.X * scalar, vector.Y * scalar);
+
+        public static Vector2I<T> operator *(T scalar, Vector2I<T> vector) =>
+            new Vector2I<T>(scalar * vector.X, scalar * vector.Y);
+
+        public static Vector2I<T> operator /(Vector2I<T> vector, T scalar) =>
+            new Vector2I<T>(vector.X / scalar, vector.Y / scalar);
+
+        public static Vector2I<T> operator %(Vector2I<T> vector, T scalar) =>
+            new Vector2I<T>(vector.X % scalar, vector.Y % scalar);
+
+        public static Vector2I<T> operator ~(Vector2I<T> vector) =>
+            new Vector2I<T>(~vector.X, ~vector.Y);
+
+        public static Vector2I<T> operator &(Vector2I<T> left, Vector2I<T> right) =>
+            new Vector2I<T>(left.X & right.X, left.Y & right.Y);
+
+        public static Vector2I<T> operator |(Vector2I<T> left, Vector2I<T> right) =>
+            new Vector2I<T>(left.X | right.X, left.Y | right.Y);
+
+        public static Vector2I<T> operator ^(Vector2I<T> left, Vector2I<T> right) =>
+            new Vector2I<T>(left.X ^ right.X, left.Y ^ right.Y);
+
+        public static Vector2I<T> operator &(Vector2I<T> vector, T scalar) =>
+            new Vector2I<T>(vector.X & scalar, vector.Y & scalar);
+
+        public static Vector2I<T> operator &(T scalar, Vector2I<T> vector) =>
+            new Vector2I<T>(scalar & vector.X, scalar & vector.Y);
+
+        public static Vector2I<T> operator |(Vector2I<T> vector, T scalar) =>
+            new Vector2I<T>(vector.X | scalar, vector.Y | scalar);
+
+        public static Vector2I<T> operator |(T scalar, Vector2I<T> vector) =>
+            new Vector2I<T>(scalar | vector.X, scalar | vector.Y);
+
+        public static Vector2I<T> operator ^(Vector2I<T> vector, T scalar) =>
+            new Vector2I<T>(vector.X ^ scalar, vector.Y ^ scalar);
+
+        public static Vector2I<T> operator ^(T scalar, Vector2I<T> vector) =>
+            new Vector2I<T>(scalar ^ vector.X, scalar ^ vector.Y);
     }
 
     static partial class Vector2I
     {
+        /// <summary>Computes the dot product of two vectors.</summary>
+        public static T Dot<T>(this Vector2I<T> left, Vector2I<T> right)
+            where T : IBinaryInteger<T> =>
+            left.X * right.X + left.Y * right.Y;
+
+        /// <summary>Reflects a vector over a normal vector.</summary>
+        public static Vector2I<T> Reflect<T>(Vector2I<T> vector, Vector2I<T> normal)
+            where T : IBinaryInteger<T>
+        {
+            T dot = vector.Dot(normal);
+            return vector - (normal * (dot + dot));
+        }
+
         public static Vector2I<TSelf> Log<TSelf>(this Vector2I<TSelf> x)
             where TSelf : IBinaryInteger<TSelf>, ILogarithmicFunctions<TSelf> =>
             new(TSelf.Log(x.X), TSelf.Log(x.Y));
diff --git a/sources/Maths/Maths/Vector3F.gen.cs b/sources/Maths/Maths/Vector3F.gen.cs
index 93b997b6e1..6c9a8a9f67 100644
--- a/sources/Maths/Maths/Vector3F.gen.cs
+++ b/sources/Maths/Maths/Vector3F.gen.cs
@@ -3,10 +3,18 @@ namespace Silk.NET.Maths
     using System.Collections;
     using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
+    using System.Runtime.InteropServices;
+    using System.Text;
 
     partial struct Vector3F<T> :
         IEquatable<Vector3F<T>>,
-        IReadOnlyList<T>
+        IReadOnlyList<T>,
+        IFormattable,
+        IParsable<Vector3F<T>>,
+        ISpanFormattable,
+        ISpanParsable<Vector3F<T>>,
+        IUtf8SpanFormattable,
+        IUtf8SpanParsable<Vector3F<T>>
         where T : IFloatingPointIeee754<T>
     {
         /// <summary>The X component of the vector.</summary>
@@ -24,6 +32,38 @@ partial struct Vector3F<T> :
         /// <summary>Initializes the vector with individual component values.</summary>
         public Vector3F(T x, T y, T z) => (X, Y, Z) = (x, y, z);
 
+        /// <summary> Initializes the vector using a <see cref="Vector2F{T}"/> for the initial elements, and the specified component for the remainder. </summary>
+        public Vector3F(Vector2F<T> other, T z) => (X, Y, Z) = (other.X, other.Y, z);
+
+        /// <summary>Initializes the vector from a span of 3 values.</summary>
+        public Vector3F(ReadOnlySpan<T> values)
+        {
+            if (values.Length != 3)
+                throw new ArgumentException("Input span must contain exactly 3 elements.", nameof(values));
+
+            X = values[0];
+            Y = values[1];
+            Z = values[2];
+        }
+
+        /// <summary>Gets a vector whose 3 elements are equal to one.</summary>
+        public static Vector3F<T> One => new(Scalar<T>.One);
+
+        /// <summary>Returns a vector whose 3 elements are equal to zero.</summary>
+        public static Vector3F<T> Zero => default;
+
+        /// <summary>Gets the vector (1, 0, 0).</summary>
+        public static Vector3F<T> UnitX => new(Scalar<T>.One, Scalar<T>.Zero, Scalar<T>.Zero);
+
+        /// <summary>Gets the vector (0, 1, 0).</summary>
+        public static Vector3F<T> UnitY => new(Scalar<T>.Zero, Scalar<T>.One, Scalar<T>.Zero);
+
+        /// <summary>Gets the vector (0, 0, 1).</summary>
+        public static Vector3F<T> UnitZ => new(Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.One);
+
+        /// <summary>Gets the squared length of the vector (dot product with itself).</summary>
+        public T LengthSquared => Vector3F.Dot(this, this);
+
         /// <inheritdoc/>
         T IReadOnlyList<T>.this[int index] => this[index];
 
@@ -61,6 +101,220 @@ public IEnumerator<T> GetEnumerator()
             yield return Z;
         }
 
+        /// <summary>Copies the components of the vector to the specified array starting at index 0.</summary>
+        public void CopyTo(T[] array) => CopyTo(array, 0);
+
+        /// <summary>Copies the components of the vector to the specified array starting at the given index.</summary>
+        public void CopyTo(T[] array, int startIndex)
+        {
+            if (array == null)
+                throw new ArgumentNullException(nameof(array));
+            if (startIndex < 0 || startIndex + 3 > array.Length)
+                throw new ArgumentOutOfRangeException(nameof(startIndex));
+
+            array[startIndex] = X;
+            array[startIndex + 1] = Y;
+            array[startIndex + 2] = Z;
+        }
+
+        /// <summary>Copies the components of the vector to the specified span starting at index 0.</summary>
+        public void CopyTo(Span<T> span) => CopyTo(span, 0);
+
+        /// <summary>Copies the components of the vector to the specified span starting at the given index.</summary>
+        public void CopyTo(Span<T> span, int startIndex)
+        {
+            if (startIndex < 0 || startIndex + 3 > span.Length)
+                throw new ArgumentOutOfRangeException(nameof(startIndex));
+
+            span[startIndex] = X;
+            span[startIndex + 1] = Y;
+            span[startIndex + 2] = Z;
+        }
+
+        /// <summary>Returns a span over the vector components.</summary>
+        public Span<T> AsSpan() => MemoryMarshal.CreateSpan(ref X, 3);
+
+        /// <summary>Formats the vector as a string.</summary>
+        public override string ToString() =>
+            $"<{X}, {Y}, {Z}>";
+
+        /// <summary>Formats the vector as a string using the specified format and format provider.</summary>
+        public string ToString(string? format, IFormatProvider? formatProvider) =>
+            $"<{X.ToString(format, formatProvider)}, {Y.ToString(format, formatProvider)}, {Z.ToString(format, formatProvider)}>";
+
+        /// <summary>Parses a string to a <see cref="Vector3F{T}"/> instance.</summary>
+        public static Vector3F<T> Parse(string s, IFormatProvider? provider) => Parse(s.AsSpan(), provider);
+
+        /// <summary>Parses a span to a <see cref="Vector3F{T}"/> instance.</summary>
+        public static Vector3F<T> Parse(ReadOnlySpan<char> s, IFormatProvider? provider)
+        {
+            if (!TryParse(s, provider, out var result))
+                throw new FormatException("Invalid format for Vector3F.");
+
+            return result;
+        }
+
+        /// <summary>Formats the vector as a UTF-8 string using the specified format and format provider.</summary>
+        public bool TryFormat(Span<byte> utf8Destination, out int bytesWritten, ReadOnlySpan<char> format, IFormatProvider? provider)
+        {
+            Span<char> xBuffer = stackalloc char[64];
+            Span<char> yBuffer = stackalloc char[64];
+            Span<char> zBuffer = stackalloc char[64];
+
+            if (!X.TryFormat(xBuffer, out int xChars, format, provider)||
+                !Y.TryFormat(yBuffer, out int yChars, format, provider)||
+                !Z.TryFormat(zBuffer, out int zChars, format, provider))
+            {
+                bytesWritten = 0;
+                return false;
+            }
+
+            int estimatedSize = Encoding.UTF8.GetByteCount(xBuffer[..xChars]) +
+                                Encoding.UTF8.GetByteCount(yBuffer[..yChars]) +
+                                Encoding.UTF8.GetByteCount(zBuffer[..zChars]) +
+                                Encoding.UTF8.GetByteCount("<, >");
+
+            if (utf8Destination.Length < estimatedSize)
+            {
+                bytesWritten = 0;
+                return false;
+            }
+
+            int totalBytes = 0;
+
+            totalBytes += Encoding.UTF8.GetBytes("<", utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(xBuffer[..xChars], utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(", ", utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(yBuffer[..yChars], utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(", ", utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(zBuffer[..zChars], utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(">", utf8Destination[totalBytes..]);
+
+            bytesWritten = totalBytes;
+            return true;
+        }
+
+        /// <summary>Formats the vector as a string using the specified format and format provider.</summary>
+        public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format, IFormatProvider? provider)
+        {
+            Span<char> xBuffer = stackalloc char[64];
+            Span<char> yBuffer = stackalloc char[64];
+            Span<char> zBuffer = stackalloc char[64];
+
+            if (!X.TryFormat(xBuffer, out int xChars, format, provider) ||
+                !Y.TryFormat(yBuffer, out int yChars, format, provider) ||
+                !Z.TryFormat(zBuffer, out int zChars, format, provider))
+            {
+                charsWritten = 0;
+                return false;
+            }
+
+            int requiredLength = 1 + xChars + 2 + yChars + 2 + zChars + 1;
+
+            if (destination.Length < requiredLength)
+            {
+                charsWritten = 0;
+                return false;
+            }
+
+            int pos = 0;
+            destination[pos++] = '<';
+
+            xBuffer[..xChars].CopyTo(destination[pos..]);
+            pos += xChars;
+
+            destination[pos++] = ',';
+            destination[pos++] = ' ';
+
+            yBuffer[..yChars].CopyTo(destination[pos..]);
+            pos += yChars;
+
+            destination[pos++] = ',';
+            destination[pos++] = ' ';
+
+            zBuffer[..zChars].CopyTo(destination[pos..]);
+            pos += zChars;
+
+            destination[pos++] = '>';
+
+            charsWritten = pos;
+            return true;
+        }
+
+        /// <summary>Tries to parse a span to a <see cref="Vector3F{T}"/> instance.</summary>
+        public static bool TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector3F<T> result)
+        {
+            result = default;
+
+            s = s.Trim();
+            if (s.Length < 6 || s[0] != '<' || s[^1] != '>')
+                return false;
+
+            s = s[1..^1]; // Remove < and >
+
+            int commaX = s.IndexOf(',');
+            if (commaX < 0)
+                return false;
+
+            ReadOnlySpan<char> remainder1 = s.Slice(commaX + 1);
+            int commaYRelative = remainder1.IndexOf(',');
+            if (commaYRelative < 0)
+                return false;
+            int commaY = commaX + 1 + commaYRelative;
+
+            ReadOnlySpan<char> xSpan = s[..commaX].Trim();
+            ReadOnlySpan<char> ySpan = s[(commaX + 1)..commaY].Trim();
+            ReadOnlySpan<char> zSpan = s[(commaY + 1)..].Trim();
+
+            if (T.TryParse(xSpan, provider, out var x) &&
+                T.TryParse(ySpan, provider, out var y) &&
+                T.TryParse(zSpan, provider, out var z))
+            {
+                result = new Vector3F<T>(x, y, z);
+                return true;
+            }
+
+            return false;
+        }
+
+        /// <summary>Parses a UTF-8 span to a <see cref="Vector3F{T}"/> instance.</summary>
+        public static Vector3F<T> Parse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider)
+        {
+            int charCount = Encoding.UTF8.GetCharCount(utf8Text);
+            Span<char> charBuffer = charCount <= 128 ? stackalloc char[charCount] : new char[charCount];
+            Encoding.UTF8.GetChars(utf8Text, charBuffer);
+            return Parse(charBuffer, provider);
+        }
+
+        /// <summary>Tries to parse a UTF-8 span to a <see cref="Vector3F{T}"/> instance.</summary>
+        public static bool TryParse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector3F<T> result)
+        {
+            int charCount = Encoding.UTF8.GetCharCount(utf8Text);
+            Span<char> charBuffer = charCount <= 128 ? stackalloc char[charCount] : new char[charCount];
+            Encoding.UTF8.GetChars(utf8Text, charBuffer);
+            return TryParse(charBuffer, provider, out result);
+        }
+
+        /// <summary>Tries to parse a string to a <see cref="Vector3F{T}"/> instance.</summary>
+        public static bool TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector3F<T> result) =>
+            TryParse(s.AsSpan(), provider, out result);
+
+        /// <summary>Parses a span to a <see cref="Vector3F{T}"/> instance.</summary>
+        static Vector3F<T> ISpanParsable<Vector3F<T>>.Parse(ReadOnlySpan<char> s, IFormatProvider? provider) =>
+            Parse(s, provider);
+
+        /// <summary>Parses a string to a <see cref="Vector3F{T}"/> instance.</summary>
+        static Vector3F<T> IParsable<Vector3F<T>>.Parse(string s, IFormatProvider? provider) =>
+            Parse(s, provider);
+
+        /// <summary>Tries to parse a span to a <see cref="Vector3F{T}"/> instance.</summary>
+        static bool ISpanParsable<Vector3F<T>>.TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector3F<T> result) =>
+            TryParse(s, provider, out result);
+
+        /// <summary>Tries to parse a string to a <see cref="Vector3F{T}"/> instance.</summary>
+        static bool IParsable<Vector3F<T>>.TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector3F<T> result) =>
+            TryParse(s, provider, out result);
+
         /// <summary>Returns a boolean indicating whether the given two vectors are equal.</summary>
         /// <param name="left">The first vector to compare.</param>
         /// <param name="right">The second vector to compare.</param>
@@ -84,10 +338,76 @@ public IEnumerator<T> GetEnumerator()
 
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(X, Y, Z);
+
+        public static Vector3F<T> operator +(Vector3F<T> vector) =>
+            vector;
+
+        public static Vector3F<T> operator -(Vector3F<T> vector) =>
+            new Vector3F<T>(-vector.X, -vector.Y, -vector.Z);
+
+        public static Vector3F<T> operator +(Vector3F<T> left, Vector3F<T> right) =>
+            new Vector3F<T>(left.X + right.X, left.Y + right.Y, left.Z + right.Z);
+
+        public static Vector3F<T> operator -(Vector3F<T> left, Vector3F<T> right) =>
+            new Vector3F<T>(left.X - right.X, left.Y - right.Y, left.Z - right.Z);
+
+        public static Vector3F<T> operator *(Vector3F<T> left, Vector3F<T> right) =>
+            new Vector3F<T>(left.X * right.X, left.Y * right.Y, left.Z * right.Z);
+
+        public static Vector3F<T> operator /(Vector3F<T> left, Vector3F<T> right) =>
+            new Vector3F<T>(left.X / right.X, left.Y / right.Y, left.Z / right.Z);
+
+        public static Vector3F<T> operator %(Vector3F<T> left, Vector3F<T> right) =>
+            new Vector3F<T>(left.X % right.X, left.Y % right.Y, left.Z % right.Z);
+
+        public static Vector3F<T> operator +(Vector3F<T> vector, T scalar) =>
+            new Vector3F<T>(vector.X + scalar, vector.Y + scalar, vector.Z + scalar);
+
+        public static Vector3F<T> operator -(Vector3F<T> vector, T scalar) =>
+            new Vector3F<T>(vector.X - scalar, vector.Y - scalar, vector.Z - scalar);
+
+        public static Vector3F<T> operator *(Vector3F<T> vector, T scalar) =>
+            new Vector3F<T>(vector.X * scalar, vector.Y * scalar, vector.Z * scalar);
+
+        public static Vector3F<T> operator *(T scalar, Vector3F<T> vector) =>
+            new Vector3F<T>(scalar * vector.X, scalar * vector.Y, scalar * vector.Z);
+
+        public static Vector3F<T> operator /(Vector3F<T> vector, T scalar) =>
+            new Vector3F<T>(vector.X / scalar, vector.Y / scalar, vector.Z / scalar);
+
+        public static Vector3F<T> operator %(Vector3F<T> vector, T scalar) =>
+            new Vector3F<T>(vector.X % scalar, vector.Y % scalar, vector.Z % scalar);
+
     }
 
     static partial class Vector3F
     {
+        /// <summary>Computes the dot product of two vectors.</summary>
+        public static T Dot<T>(this Vector3F<T> left, Vector3F<T> right)
+            where T : IFloatingPointIeee754<T> =>
+            left.X * right.X + left.Y * right.Y + left.Z * right.Z;
+
+        /// <summary>Reflects a vector over a normal vector.</summary>
+        public static Vector3F<T> Reflect<T>(Vector3F<T> vector, Vector3F<T> normal)
+            where T : IFloatingPointIeee754<T>
+        {
+            T dot = vector.Dot(normal);
+            return vector - (normal * (dot + dot));
+        }
+
+        /// <summary>Computes the length of the vector.</summary>
+        public static T GetLength<T>(this Vector3F<T> vector)
+            where T : IFloatingPointIeee754<T> =>
+            T.Sqrt(vector.LengthSquared);
+
+        /// <summary>Normalizes a vector.</summary>
+        public static Vector3F<T> Normalize<T>(this Vector3F<T> vector)
+            where T : IFloatingPointIeee754<T>
+        {
+            T length = vector.GetLength();
+            return length != T.Zero ? vector / length : Vector3F<T>.Zero;
+        }
+
         public static Vector3F<TSelf> Log<TSelf>(this Vector3F<TSelf> x)
             where TSelf : IFloatingPointIeee754<TSelf>, ILogarithmicFunctions<TSelf> =>
             new(TSelf.Log(x.X), TSelf.Log(x.Y), TSelf.Log(x.Z));
diff --git a/sources/Maths/Maths/Vector3I.cs b/sources/Maths/Maths/Vector3I.cs
index ac7a810b7d..167273b467 100644
--- a/sources/Maths/Maths/Vector3I.cs
+++ b/sources/Maths/Maths/Vector3I.cs
@@ -12,57 +12,8 @@
 namespace Silk.NET.Maths
 {
     /// <summary>A structure representing a 3D integer vector.</summary>
-    internal partial struct Vector3I<T> :
-        ISpanFormattable,
-        ISpanParsable<Vector3I<T>>,
-        IUtf8SpanFormattable,
-        IUtf8SpanParsable<Vector3I<T>>,
-        IParsable<Vector3I<T>>,
-        IFormattable
-        where T : IBinaryInteger<T>
+    internal partial struct Vector3I<T>
     {
-        /// <summary>Initializes the vector from a span of three values.</summary>
-        public Vector3I(ReadOnlySpan<T> values)
-        {
-            if (values.Length != 3)
-                throw new ArgumentException("Input span must contain exactly 3 elements.", nameof(values));
-
-            X = values[0];
-            Y = values[1];
-            Z = values[2];
-        }
-
-        /// <summary> Initializes the vector using a Vector2I for X and Y, and a separate value for Z. </summary>
-        // TODO: Make sure lower dimensional constructors arent meant to zero-out the higher dimensions
-        public Vector3I(Vector2I<T> xy, T z) => (X, Y, Z) = (xy.X, xy.Y, z);
-
-        /// <summary>Gets a vector whose 3 elements are equal to one.</summary>
-        public static Vector3I<T> One => new(Scalar<T>.One);
-
-        /// <summary>Returns a vector whose 3 elements are equal to zero.</summary>
-        public static Vector3I<T> Zero => default;
-
-        /// <summary>Gets the vector (1, 0, 0).</summary>
-        public static Vector3I<T> UnitX => new(Scalar<T>.One, Scalar<T>.Zero, Scalar<T>.Zero);
-
-        /// <summary>Gets the vector (0, 1, 0).</summary>
-        public static Vector3I<T> UnitY => new(Scalar<T>.Zero, Scalar<T>.One, Scalar<T>.Zero);
-
-        /// <summary>Gets the vector (0, 0, 1).</summary>
-        public static Vector3I<T> UnitZ => new(Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.One);
-
-        /// <summary>Gets a vector with all bits set for each component.</summary>
-        public static Vector3I<T> AllBitsSet => new Vector3I<T>(T.AllBitsSet, T.AllBitsSet, T.AllBitsSet);
-
-        /// <summary>Gets the squared length of the vector (dot product with itself).</summary>
-        public T LengthSquared => (X * X) + (Y * Y) + (Z * Z);
-
-        /// <summary> Computes the dot product of this vector with another vector. </summary>
-        public T Dot(Vector3I<T> other) => (X * other.X) + (Y * other.Y) + (Z * other.Z);
-
-        /// <summary> Computes the dot product of two vectors. </summary>
-        public static T Dot(Vector3I<T> left, Vector3I<T> right) => (left.X * right.X) + (left.Y * right.Y) + (left.Z * right.Z);
-
         /// <summary> Computes the cross product of this vector with another vector. </summary>
         public Vector3I<T> Cross(Vector3I<T> other) =>
             new Vector3I<T>(
@@ -79,9 +30,6 @@ public static Vector3I<T> Cross(Vector3I<T> left, Vector3I<T> right) =>
                 (left.X * right.Y) - (left.Y * right.X)
             );
 
-        /// <summary>Returns a span over the vector components.</summary>
-        public Span<T> AsSpan() => MemoryMarshal.CreateSpan(ref X, 3);
-
         /// <summary>Returns a vector with the component-wise maximum of this and another vector.</summary>
         public Vector3I<T> Max(Vector3I<T> other) =>
             new Vector3I<T>(T.Max(X, other.X), T.Max(Y, other.Y), T.Max(Z, other.Z));
@@ -153,99 +101,6 @@ public static Vector3I<T> Clamp(Vector3I<T> vector, T min, T max) =>
         public static Vector3I<T> Abs(Vector3I<T> vector) =>
             new Vector3I<T>(T.Abs(vector.X), T.Abs(vector.Y), T.Abs(vector.Z));
 
-        /// <summary>Formats the vector as a string using the specified format and format provider.</summary>
-        public string ToString(string? format, IFormatProvider? formatProvider) =>
-            $"<{X.ToString(format, formatProvider)}, {Y.ToString(format, formatProvider)}, {Z.ToString(format, formatProvider)}>";
-
-        /// <summary>Formats the vector as a string.</summary>
-        public override string ToString() => $"<{X}, {Y}, {Z}>";
-
-        /// <summary>Formats the vector as a string using the specified format and format provider.</summary>
-        public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format, IFormatProvider? provider)
-        {
-            // Format components individually into temporary buffers
-            Span<char> xBuffer = stackalloc char[64];
-            Span<char> yBuffer = stackalloc char[64];
-            Span<char> zBuffer = stackalloc char[64];
-
-            if (!X.TryFormat(xBuffer, out int xChars, format, provider) ||
-                !Y.TryFormat(yBuffer, out int yChars, format, provider) ||
-                !Z.TryFormat(zBuffer, out int zChars, format, provider))
-            {
-                charsWritten = 0;
-                return false;
-            }
-
-            // Calculate total required length: < + x + ", " + y + ", " + z + >
-            int requiredLength = 1 + xChars + 2 + yChars + 2 + zChars + 1;
-
-            if (destination.Length < requiredLength)
-            {
-                charsWritten = 0;
-                return false;
-            }
-
-            int pos = 0;
-            destination[pos++] = '<';
-
-            xBuffer[..xChars].CopyTo(destination[pos..]);
-            pos += xChars;
-
-            destination[pos++] = ',';
-            destination[pos++] = ' ';
-
-            yBuffer[..yChars].CopyTo(destination[pos..]);
-            pos += yChars;
-
-            destination[pos++] = ',';
-            destination[pos++] = ' ';
-
-            zBuffer[..zChars].CopyTo(destination[pos..]);
-            pos += zChars;
-
-            destination[pos++] = '>';
-
-            charsWritten = pos;
-            return true;
-        }
-
-        /// <summary>Parses a span to a <see cref="Vector3I{T}"/> instance.</summary>
-        public static Vector3I<T> Parse(ReadOnlySpan<char> s, IFormatProvider? provider)
-        {
-            if (!TryParse(s, provider, out var result))
-                throw new FormatException("Invalid format for Vector3I.");
-
-            return result;
-        }
-
-        /// <summary>Copies the components of the vector to the specified array starting at index 0.</summary>
-        public void CopyTo(T[] array) => CopyTo(array, 0);
-
-        /// <summary>Copies the components of the vector to the specified array starting at the given index.</summary>
-        public void CopyTo(T[] array, int startIndex)
-        {
-            if (array == null)
-                throw new ArgumentNullException(nameof(array));
-            if (startIndex < 0 || startIndex + 3 > array.Length)
-                throw new ArgumentOutOfRangeException(nameof(startIndex));
-            array[startIndex] = X;
-            array[startIndex + 1] = Y;
-            array[startIndex + 2] = Z;
-        }
-
-        /// <summary>Copies the components of the vector to the specified span starting at index 0.</summary>
-        public void CopyTo(Span<T> span) => CopyTo(span, 0);
-
-        /// <summary>Copies the components of the vector to the specified span starting at the given index.</summary>
-        public void CopyTo(Span<T> span, int startIndex)
-        {
-            if (startIndex < 0 || startIndex + 3 > span.Length)
-                throw new ArgumentOutOfRangeException(nameof(startIndex));
-            span[startIndex] = X;
-            span[startIndex + 1] = Y;
-            span[startIndex + 2] = Z;
-        }
-
         /// <summary>Returns a vector where each component is the sign of the original vector's component.</summary>
         public Vector3I<T> Sign() =>
             new Vector3I<T>(T.CreateChecked(T.Sign(X)), T.CreateChecked(T.Sign(Y)), T.CreateChecked(T.Sign(Z)));
@@ -270,130 +125,6 @@ public Vector3I<T> CopySign(T signScalar) =>
         public static Vector3I<T> CopySign(Vector3I<T> value, T signScalar) =>
             new Vector3I<T>(T.CopySign(value.X, signScalar), T.CopySign(value.Y, signScalar), T.CopySign(value.Z, signScalar));
 
-        /// <summary>Parses a string to a <see cref="Vector3I{T}"/> instance.</summary>
-        public static Vector3I<T> Parse(string s, IFormatProvider? provider) => Parse(s.AsSpan(), provider);
-
-        /// <summary>Tries to parse a span to a <see cref="Vector3I{T}"/> instance.</summary>
-        public static bool TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector3I<T> result)
-        {
-            result = default;
-
-            s = s.Trim();
-            if (s.Length < 7 || s[0] != '<' || s[^1] != '>')
-                return false;
-
-            s = s[1..^1]; // Remove < and >
-
-            int firstComma = s.IndexOf(',');
-            if (firstComma < 0)
-                return false;
-
-            // Kind of hacky, but it works
-            // TODO: See if there's a better way
-            ReadOnlySpan<char> remainder = s.Slice(firstComma + 1);
-            int secondCommaRelative = remainder.IndexOf(',');
-            if (secondCommaRelative < 0)
-                return false;
-
-            int secondComma = firstComma + 1 + secondCommaRelative;
-            if (secondComma < 0)
-                return false;
-
-            ReadOnlySpan<char> xSpan = s[..firstComma].Trim();
-            ReadOnlySpan<char> ySpan = s[(firstComma + 1)..secondComma].Trim();
-            ReadOnlySpan<char> zSpan = s[(secondComma + 1)..].Trim();
-
-            if (T.TryParse(xSpan, provider, out var x) &&
-                T.TryParse(ySpan, provider, out var y) &&
-                T.TryParse(zSpan, provider, out var z))
-            {
-                result = new Vector3I<T>(x, y, z);
-                return true;
-            }
-
-            return false;
-        }
-
-        /// <summary>Tries to parse a string to a <see cref="Vector3I{T}"/> instance.</summary>
-        public static bool TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector3I<T> result) =>
-            TryParse(s.AsSpan(), provider, out result);
-
-        /// <summary>Parses a span to a <see cref="Vector3I{T}"/> instance.</summary>
-        static Vector3I<T> ISpanParsable<Vector3I<T>>.Parse(ReadOnlySpan<char> s, IFormatProvider? provider) =>
-            Parse(s, provider);
-
-        /// <summary>Parses a string to a <see cref="Vector3I{T}"/> instance.</summary>
-        static Vector3I<T> IParsable<Vector3I<T>>.Parse(string s, IFormatProvider? provider) =>
-            Parse(s, provider);
-
-        /// <summary>Tries to parse a span to a <see cref="Vector3I{T}"/> instance.</summary>
-        static bool ISpanParsable<Vector3I<T>>.TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector3I<T> result) =>
-            TryParse(s, provider, out result);
-
-        /// <summary>Tries to parse a string to a <see cref="Vector3I{T}"/> instance.</summary>
-        static bool IParsable<Vector3I<T>>.TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector3I<T> result) =>
-            TryParse(s, provider, out result);
-
-        /// <summary>Formats the vector as a UTF-8 string using the specified format and format provider.</summary>
-        public bool TryFormat(Span<byte> utf8Destination, out int bytesWritten, ReadOnlySpan<char> format, IFormatProvider? provider)
-        {
-            // Format components individually into temporary buffers
-            Span<char> xBuffer = stackalloc char[64];
-            Span<char> yBuffer = stackalloc char[64];
-            Span<char> zBuffer = stackalloc char[64];
-
-            if (!X.TryFormat(xBuffer, out int xChars, format, provider) ||
-                !Y.TryFormat(yBuffer, out int yChars, format, provider) ||
-                !Z.TryFormat(zBuffer, out int zChars, format, provider))
-            {
-                bytesWritten = 0;
-                return false;
-            }
-
-            // Estimate total required UTF-8 bytes
-            int estimatedSize = Encoding.UTF8.GetByteCount(xBuffer[..xChars]) +
-                               Encoding.UTF8.GetByteCount(yBuffer[..yChars]) +
-                               Encoding.UTF8.GetByteCount(zBuffer[..zChars]) +
-                               Encoding.UTF8.GetByteCount("<, , >");
-
-            if (utf8Destination.Length < estimatedSize)
-            {
-                bytesWritten = 0;
-                return false;
-            }
-
-            int totalBytes = 0;
-
-            totalBytes += Encoding.UTF8.GetBytes("<", utf8Destination[totalBytes..]);
-            totalBytes += Encoding.UTF8.GetBytes(xBuffer[..xChars], utf8Destination[totalBytes..]);
-            totalBytes += Encoding.UTF8.GetBytes(", ", utf8Destination[totalBytes..]);
-            totalBytes += Encoding.UTF8.GetBytes(yBuffer[..yChars], utf8Destination[totalBytes..]);
-            totalBytes += Encoding.UTF8.GetBytes(", ", utf8Destination[totalBytes..]);
-            totalBytes += Encoding.UTF8.GetBytes(zBuffer[..zChars], utf8Destination[totalBytes..]);
-            totalBytes += Encoding.UTF8.GetBytes(">", utf8Destination[totalBytes..]);
-
-            bytesWritten = totalBytes;
-            return true;
-        }
-
-        /// <summary>Parses a UTF-8 span to a <see cref="Vector3I{T}"/> instance.</summary>
-        public static Vector3I<T> Parse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider)
-        {
-            int charCount = Encoding.UTF8.GetCharCount(utf8Text);
-            Span<char> charBuffer = charCount <= 128 ? stackalloc char[charCount] : new char[charCount];
-            Encoding.UTF8.GetChars(utf8Text, charBuffer);
-            return Parse(charBuffer, provider);
-        }
-
-        /// <summary>Tries to parse a UTF-8 span to a <see cref="Vector3I{T}"/> instance.</summary>
-        public static bool TryParse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector3I<T> result)
-        {
-            int charCount = Encoding.UTF8.GetCharCount(utf8Text);
-            Span<char> charBuffer = charCount <= 128 ? stackalloc char[charCount] : new char[charCount];
-            Encoding.UTF8.GetChars(utf8Text, charBuffer);
-            return TryParse(charBuffer, provider, out result);
-        }
-
         // Casts
 
         /// <summary>Explicitly casts a <see cref="System.Numerics.Vector3"/> to a <see cref="Vector3I{T}"/>.</summary>
@@ -404,77 +135,6 @@ public static explicit operator Vector3I<T>(System.Numerics.Vector3 v) =>
         public static explicit operator System.Numerics.Vector3(Vector3I<T> v) =>
             new System.Numerics.Vector3(Convert.ToSingle(v.X), Convert.ToSingle(v.Y), Convert.ToSingle(v.Z));
 
-        // Component Operators
-        public static Vector3I<T> operator +(Vector3I<T> left, Vector3I<T> right) =>
-            new Vector3I<T>(left.X + right.X, left.Y + right.Y, left.Z + right.Z);
-
-        public static Vector3I<T> operator -(Vector3I<T> left, Vector3I<T> right) =>
-            new Vector3I<T>(left.X - right.X, left.Y - right.Y, left.Z - right.Z);
-
-        public static Vector3I<T> operator *(Vector3I<T> left, Vector3I<T> right) =>
-            new Vector3I<T>(left.X * right.X, left.Y * right.Y, left.Z * right.Z);
-
-        public static Vector3I<T> operator /(Vector3I<T> left, Vector3I<T> right) =>
-            new Vector3I<T>(left.X / right.X, left.Y / right.Y, left.Z / right.Z);
-
-        public static Vector3I<T> operator %(Vector3I<T> left, Vector3I<T> right) =>
-            new Vector3I<T>(left.X % right.X, left.Y % right.Y, left.Z % right.Z);
-
-        // Scalar Operators
-        public static Vector3I<T> operator +(Vector3I<T> vector, T scalar) =>
-            new Vector3I<T>(vector.X + scalar, vector.Y + scalar, vector.Z + scalar);
-
-        public static Vector3I<T> operator -(Vector3I<T> vector, T scalar) =>
-            new Vector3I<T>(vector.X - scalar, vector.Y - scalar, vector.Z - scalar);
-
-        public static Vector3I<T> operator *(Vector3I<T> vector, T scalar) =>
-            new Vector3I<T>(vector.X * scalar, vector.Y * scalar, vector.Z * scalar);
-
-        public static Vector3I<T> operator /(Vector3I<T> vector, T scalar) =>
-            new Vector3I<T>(vector.X / scalar, vector.Y / scalar, vector.Z / scalar);
-
-        public static Vector3I<T> operator %(Vector3I<T> vector, T scalar) =>
-            new Vector3I<T>(vector.X % scalar, vector.Y % scalar, vector.Z % scalar);
-
-        // + operator: returns the vector (?)
-        public static Vector3I<T> operator +(Vector3I<T> vector) => vector;
-
-        //  - operator: returns the negated vector
-        public static Vector3I<T> operator -(Vector3I<T> vector) =>
-            new Vector3I<T>(-vector.X, -vector.Y, -vector.Z);
-
-        // Bitwise Operators
-        public static Vector3I<T> operator &(Vector3I<T> left, Vector3I<T> right) =>
-            new Vector3I<T>(left.X & right.X, left.Y & right.Y, left.Z & right.Z);
-
-        public static Vector3I<T> operator |(Vector3I<T> left, Vector3I<T> right) =>
-            new Vector3I<T>(left.X | right.X, left.Y | right.Y, left.Z | right.Z);
-
-        public static Vector3I<T> operator ^(Vector3I<T> left, Vector3I<T> right) =>
-            new Vector3I<T>(left.X ^ right.X, left.Y ^ right.Y, left.Z ^ right.Z);
-
-        public static Vector3I<T> operator &(Vector3I<T> vector, T scalar) =>
-            new Vector3I<T>(vector.X & scalar, vector.Y & scalar, vector.Z & scalar);
-
-        public static Vector3I<T> operator &(T scalar, Vector3I<T> vector) =>
-            new Vector3I<T>(scalar & vector.X, scalar & vector.Y, scalar & vector.Z);
-
-        public static Vector3I<T> operator |(Vector3I<T> vector, T scalar) =>
-            new Vector3I<T>(vector.X | scalar, vector.Y | scalar, vector.Z | scalar);
-
-        public static Vector3I<T> operator |(T scalar, Vector3I<T> vector) =>
-            new Vector3I<T>(scalar | vector.X, scalar | vector.Y, scalar | vector.Z);
-
-        public static Vector3I<T> operator ^(Vector3I<T> vector, T scalar) =>
-            new Vector3I<T>(vector.X ^ scalar, vector.Y ^ scalar, vector.Z ^ scalar);
-
-        public static Vector3I<T> operator ^(T scalar, Vector3I<T> vector) =>
-            new Vector3I<T>(scalar ^ vector.X, scalar ^ vector.Y, scalar ^ vector.Z);
-
-        // NOT operator
-        public static Vector3I<T> operator ~(Vector3I<T> vector) =>
-            new Vector3I<T>(~vector.X, ~vector.Y, ~vector.Z);
-
         // IBinaryInteger
         public static Vector3I<T> Log2(Vector3I<T> x) =>
             new Vector3I<T>(T.Log2(x.X), T.Log2(x.Y), T.Log2(x.Z));
diff --git a/sources/Maths/Maths/Vector3I.gen.cs b/sources/Maths/Maths/Vector3I.gen.cs
index 45ee97e364..05bb368e10 100644
--- a/sources/Maths/Maths/Vector3I.gen.cs
+++ b/sources/Maths/Maths/Vector3I.gen.cs
@@ -3,10 +3,18 @@ namespace Silk.NET.Maths
     using System.Collections;
     using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
+    using System.Runtime.InteropServices;
+    using System.Text;
 
     partial struct Vector3I<T> :
         IEquatable<Vector3I<T>>,
-        IReadOnlyList<T>
+        IReadOnlyList<T>,
+        IFormattable,
+        IParsable<Vector3I<T>>,
+        ISpanFormattable,
+        ISpanParsable<Vector3I<T>>,
+        IUtf8SpanFormattable,
+        IUtf8SpanParsable<Vector3I<T>>
         where T : IBinaryInteger<T>
     {
         /// <summary>The X component of the vector.</summary>
@@ -24,6 +32,41 @@ partial struct Vector3I<T> :
         /// <summary>Initializes the vector with individual component values.</summary>
         public Vector3I(T x, T y, T z) => (X, Y, Z) = (x, y, z);
 
+        /// <summary> Initializes the vector using a <see cref="Vector2I{T}"/> for the initial elements, and the specified component for the remainder. </summary>
+        public Vector3I(Vector2I<T> other, T z) => (X, Y, Z) = (other.X, other.Y, z);
+
+        /// <summary>Initializes the vector from a span of 3 values.</summary>
+        public Vector3I(ReadOnlySpan<T> values)
+        {
+            if (values.Length != 3)
+                throw new ArgumentException("Input span must contain exactly 3 elements.", nameof(values));
+
+            X = values[0];
+            Y = values[1];
+            Z = values[2];
+        }
+
+        /// <summary>Gets a vector whose 3 elements are equal to one.</summary>
+        public static Vector3I<T> One => new(Scalar<T>.One);
+
+        /// <summary>Returns a vector whose 3 elements are equal to zero.</summary>
+        public static Vector3I<T> Zero => default;
+
+        /// <summary>Gets the vector (1, 0, 0).</summary>
+        public static Vector3I<T> UnitX => new(Scalar<T>.One, Scalar<T>.Zero, Scalar<T>.Zero);
+
+        /// <summary>Gets the vector (0, 1, 0).</summary>
+        public static Vector3I<T> UnitY => new(Scalar<T>.Zero, Scalar<T>.One, Scalar<T>.Zero);
+
+        /// <summary>Gets the vector (0, 0, 1).</summary>
+        public static Vector3I<T> UnitZ => new(Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.One);
+
+        /// <summary>Gets a vector with all bits set for each component.</summary>
+        public static Vector3I<T> AllBitsSet => new Vector3I<T>(T.AllBitsSet, T.AllBitsSet, T.AllBitsSet);
+
+        /// <summary>Gets the squared length of the vector (dot product with itself).</summary>
+        public T LengthSquared => Vector3I.Dot(this, this);
+
         /// <inheritdoc/>
         T IReadOnlyList<T>.this[int index] => this[index];
 
@@ -61,6 +104,220 @@ public IEnumerator<T> GetEnumerator()
             yield return Z;
         }
 
+        /// <summary>Copies the components of the vector to the specified array starting at index 0.</summary>
+        public void CopyTo(T[] array) => CopyTo(array, 0);
+
+        /// <summary>Copies the components of the vector to the specified array starting at the given index.</summary>
+        public void CopyTo(T[] array, int startIndex)
+        {
+            if (array == null)
+                throw new ArgumentNullException(nameof(array));
+            if (startIndex < 0 || startIndex + 3 > array.Length)
+                throw new ArgumentOutOfRangeException(nameof(startIndex));
+
+            array[startIndex] = X;
+            array[startIndex + 1] = Y;
+            array[startIndex + 2] = Z;
+        }
+
+        /// <summary>Copies the components of the vector to the specified span starting at index 0.</summary>
+        public void CopyTo(Span<T> span) => CopyTo(span, 0);
+
+        /// <summary>Copies the components of the vector to the specified span starting at the given index.</summary>
+        public void CopyTo(Span<T> span, int startIndex)
+        {
+            if (startIndex < 0 || startIndex + 3 > span.Length)
+                throw new ArgumentOutOfRangeException(nameof(startIndex));
+
+            span[startIndex] = X;
+            span[startIndex + 1] = Y;
+            span[startIndex + 2] = Z;
+        }
+
+        /// <summary>Returns a span over the vector components.</summary>
+        public Span<T> AsSpan() => MemoryMarshal.CreateSpan(ref X, 3);
+
+        /// <summary>Formats the vector as a string.</summary>
+        public override string ToString() =>
+            $"<{X}, {Y}, {Z}>";
+
+        /// <summary>Formats the vector as a string using the specified format and format provider.</summary>
+        public string ToString(string? format, IFormatProvider? formatProvider) =>
+            $"<{X.ToString(format, formatProvider)}, {Y.ToString(format, formatProvider)}, {Z.ToString(format, formatProvider)}>";
+
+        /// <summary>Parses a string to a <see cref="Vector3I{T}"/> instance.</summary>
+        public static Vector3I<T> Parse(string s, IFormatProvider? provider) => Parse(s.AsSpan(), provider);
+
+        /// <summary>Parses a span to a <see cref="Vector3I{T}"/> instance.</summary>
+        public static Vector3I<T> Parse(ReadOnlySpan<char> s, IFormatProvider? provider)
+        {
+            if (!TryParse(s, provider, out var result))
+                throw new FormatException("Invalid format for Vector3I.");
+
+            return result;
+        }
+
+        /// <summary>Formats the vector as a UTF-8 string using the specified format and format provider.</summary>
+        public bool TryFormat(Span<byte> utf8Destination, out int bytesWritten, ReadOnlySpan<char> format, IFormatProvider? provider)
+        {
+            Span<char> xBuffer = stackalloc char[64];
+            Span<char> yBuffer = stackalloc char[64];
+            Span<char> zBuffer = stackalloc char[64];
+
+            if (!X.TryFormat(xBuffer, out int xChars, format, provider)||
+                !Y.TryFormat(yBuffer, out int yChars, format, provider)||
+                !Z.TryFormat(zBuffer, out int zChars, format, provider))
+            {
+                bytesWritten = 0;
+                return false;
+            }
+
+            int estimatedSize = Encoding.UTF8.GetByteCount(xBuffer[..xChars]) +
+                                Encoding.UTF8.GetByteCount(yBuffer[..yChars]) +
+                                Encoding.UTF8.GetByteCount(zBuffer[..zChars]) +
+                                Encoding.UTF8.GetByteCount("<, >");
+
+            if (utf8Destination.Length < estimatedSize)
+            {
+                bytesWritten = 0;
+                return false;
+            }
+
+            int totalBytes = 0;
+
+            totalBytes += Encoding.UTF8.GetBytes("<", utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(xBuffer[..xChars], utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(", ", utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(yBuffer[..yChars], utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(", ", utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(zBuffer[..zChars], utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(">", utf8Destination[totalBytes..]);
+
+            bytesWritten = totalBytes;
+            return true;
+        }
+
+        /// <summary>Formats the vector as a string using the specified format and format provider.</summary>
+        public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format, IFormatProvider? provider)
+        {
+            Span<char> xBuffer = stackalloc char[64];
+            Span<char> yBuffer = stackalloc char[64];
+            Span<char> zBuffer = stackalloc char[64];
+
+            if (!X.TryFormat(xBuffer, out int xChars, format, provider) ||
+                !Y.TryFormat(yBuffer, out int yChars, format, provider) ||
+                !Z.TryFormat(zBuffer, out int zChars, format, provider))
+            {
+                charsWritten = 0;
+                return false;
+            }
+
+            int requiredLength = 1 + xChars + 2 + yChars + 2 + zChars + 1;
+
+            if (destination.Length < requiredLength)
+            {
+                charsWritten = 0;
+                return false;
+            }
+
+            int pos = 0;
+            destination[pos++] = '<';
+
+            xBuffer[..xChars].CopyTo(destination[pos..]);
+            pos += xChars;
+
+            destination[pos++] = ',';
+            destination[pos++] = ' ';
+
+            yBuffer[..yChars].CopyTo(destination[pos..]);
+            pos += yChars;
+
+            destination[pos++] = ',';
+            destination[pos++] = ' ';
+
+            zBuffer[..zChars].CopyTo(destination[pos..]);
+            pos += zChars;
+
+            destination[pos++] = '>';
+
+            charsWritten = pos;
+            return true;
+        }
+
+        /// <summary>Tries to parse a span to a <see cref="Vector3I{T}"/> instance.</summary>
+        public static bool TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector3I<T> result)
+        {
+            result = default;
+
+            s = s.Trim();
+            if (s.Length < 6 || s[0] != '<' || s[^1] != '>')
+                return false;
+
+            s = s[1..^1]; // Remove < and >
+
+            int commaX = s.IndexOf(',');
+            if (commaX < 0)
+                return false;
+
+            ReadOnlySpan<char> remainder1 = s.Slice(commaX + 1);
+            int commaYRelative = remainder1.IndexOf(',');
+            if (commaYRelative < 0)
+                return false;
+            int commaY = commaX + 1 + commaYRelative;
+
+            ReadOnlySpan<char> xSpan = s[..commaX].Trim();
+            ReadOnlySpan<char> ySpan = s[(commaX + 1)..commaY].Trim();
+            ReadOnlySpan<char> zSpan = s[(commaY + 1)..].Trim();
+
+            if (T.TryParse(xSpan, provider, out var x) &&
+                T.TryParse(ySpan, provider, out var y) &&
+                T.TryParse(zSpan, provider, out var z))
+            {
+                result = new Vector3I<T>(x, y, z);
+                return true;
+            }
+
+            return false;
+        }
+
+        /// <summary>Parses a UTF-8 span to a <see cref="Vector3I{T}"/> instance.</summary>
+        public static Vector3I<T> Parse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider)
+        {
+            int charCount = Encoding.UTF8.GetCharCount(utf8Text);
+            Span<char> charBuffer = charCount <= 128 ? stackalloc char[charCount] : new char[charCount];
+            Encoding.UTF8.GetChars(utf8Text, charBuffer);
+            return Parse(charBuffer, provider);
+        }
+
+        /// <summary>Tries to parse a UTF-8 span to a <see cref="Vector3I{T}"/> instance.</summary>
+        public static bool TryParse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector3I<T> result)
+        {
+            int charCount = Encoding.UTF8.GetCharCount(utf8Text);
+            Span<char> charBuffer = charCount <= 128 ? stackalloc char[charCount] : new char[charCount];
+            Encoding.UTF8.GetChars(utf8Text, charBuffer);
+            return TryParse(charBuffer, provider, out result);
+        }
+
+        /// <summary>Tries to parse a string to a <see cref="Vector3I{T}"/> instance.</summary>
+        public static bool TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector3I<T> result) =>
+            TryParse(s.AsSpan(), provider, out result);
+
+        /// <summary>Parses a span to a <see cref="Vector3I{T}"/> instance.</summary>
+        static Vector3I<T> ISpanParsable<Vector3I<T>>.Parse(ReadOnlySpan<char> s, IFormatProvider? provider) =>
+            Parse(s, provider);
+
+        /// <summary>Parses a string to a <see cref="Vector3I{T}"/> instance.</summary>
+        static Vector3I<T> IParsable<Vector3I<T>>.Parse(string s, IFormatProvider? provider) =>
+            Parse(s, provider);
+
+        /// <summary>Tries to parse a span to a <see cref="Vector3I{T}"/> instance.</summary>
+        static bool ISpanParsable<Vector3I<T>>.TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector3I<T> result) =>
+            TryParse(s, provider, out result);
+
+        /// <summary>Tries to parse a string to a <see cref="Vector3I{T}"/> instance.</summary>
+        static bool IParsable<Vector3I<T>>.TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector3I<T> result) =>
+            TryParse(s, provider, out result);
+
         /// <summary>Returns a boolean indicating whether the given two vectors are equal.</summary>
         /// <param name="left">The first vector to compare.</param>
         /// <param name="right">The second vector to compare.</param>
@@ -84,10 +341,92 @@ public IEnumerator<T> GetEnumerator()
 
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(X, Y, Z);
+
+        public static Vector3I<T> operator +(Vector3I<T> vector) =>
+            vector;
+
+        public static Vector3I<T> operator -(Vector3I<T> vector) =>
+            new Vector3I<T>(-vector.X, -vector.Y, -vector.Z);
+
+        public static Vector3I<T> operator +(Vector3I<T> left, Vector3I<T> right) =>
+            new Vector3I<T>(left.X + right.X, left.Y + right.Y, left.Z + right.Z);
+
+        public static Vector3I<T> operator -(Vector3I<T> left, Vector3I<T> right) =>
+            new Vector3I<T>(left.X - right.X, left.Y - right.Y, left.Z - right.Z);
+
+        public static Vector3I<T> operator *(Vector3I<T> left, Vector3I<T> right) =>
+            new Vector3I<T>(left.X * right.X, left.Y * right.Y, left.Z * right.Z);
+
+        public static Vector3I<T> operator /(Vector3I<T> left, Vector3I<T> right) =>
+            new Vector3I<T>(left.X / right.X, left.Y / right.Y, left.Z / right.Z);
+
+        public static Vector3I<T> operator %(Vector3I<T> left, Vector3I<T> right) =>
+            new Vector3I<T>(left.X % right.X, left.Y % right.Y, left.Z % right.Z);
+
+        public static Vector3I<T> operator +(Vector3I<T> vector, T scalar) =>
+            new Vector3I<T>(vector.X + scalar, vector.Y + scalar, vector.Z + scalar);
+
+        public static Vector3I<T> operator -(Vector3I<T> vector, T scalar) =>
+            new Vector3I<T>(vector.X - scalar, vector.Y - scalar, vector.Z - scalar);
+
+        public static Vector3I<T> operator *(Vector3I<T> vector, T scalar) =>
+            new Vector3I<T>(vector.X * scalar, vector.Y * scalar, vector.Z * scalar);
+
+        public static Vector3I<T> operator *(T scalar, Vector3I<T> vector) =>
+            new Vector3I<T>(scalar * vector.X, scalar * vector.Y, scalar * vector.Z);
+
+        public static Vector3I<T> operator /(Vector3I<T> vector, T scalar) =>
+            new Vector3I<T>(vector.X / scalar, vector.Y / scalar, vector.Z / scalar);
+
+        public static Vector3I<T> operator %(Vector3I<T> vector, T scalar) =>
+            new Vector3I<T>(vector.X % scalar, vector.Y % scalar, vector.Z % scalar);
+
+        public static Vector3I<T> operator ~(Vector3I<T> vector) =>
+            new Vector3I<T>(~vector.X, ~vector.Y, ~vector.Z);
+
+        public static Vector3I<T> operator &(Vector3I<T> left, Vector3I<T> right) =>
+            new Vector3I<T>(left.X & right.X, left.Y & right.Y, left.Z & right.Z);
+
+        public static Vector3I<T> operator |(Vector3I<T> left, Vector3I<T> right) =>
+            new Vector3I<T>(left.X | right.X, left.Y | right.Y, left.Z | right.Z);
+
+        public static Vector3I<T> operator ^(Vector3I<T> left, Vector3I<T> right) =>
+            new Vector3I<T>(left.X ^ right.X, left.Y ^ right.Y, left.Z ^ right.Z);
+
+        public static Vector3I<T> operator &(Vector3I<T> vector, T scalar) =>
+            new Vector3I<T>(vector.X & scalar, vector.Y & scalar, vector.Z & scalar);
+
+        public static Vector3I<T> operator &(T scalar, Vector3I<T> vector) =>
+            new Vector3I<T>(scalar & vector.X, scalar & vector.Y, scalar & vector.Z);
+
+        public static Vector3I<T> operator |(Vector3I<T> vector, T scalar) =>
+            new Vector3I<T>(vector.X | scalar, vector.Y | scalar, vector.Z | scalar);
+
+        public static Vector3I<T> operator |(T scalar, Vector3I<T> vector) =>
+            new Vector3I<T>(scalar | vector.X, scalar | vector.Y, scalar | vector.Z);
+
+        public static Vector3I<T> operator ^(Vector3I<T> vector, T scalar) =>
+            new Vector3I<T>(vector.X ^ scalar, vector.Y ^ scalar, vector.Z ^ scalar);
+
+        public static Vector3I<T> operator ^(T scalar, Vector3I<T> vector) =>
+            new Vector3I<T>(scalar ^ vector.X, scalar ^ vector.Y, scalar ^ vector.Z);
     }
 
     static partial class Vector3I
     {
+        /// <summary>Computes the dot product of two vectors.</summary>
+        public static T Dot<T>(this Vector3I<T> left, Vector3I<T> right)
+            where T : IBinaryInteger<T> =>
+            left.X * right.X + left.Y * right.Y + left.Z * right.Z;
+
+        /// <summary>Reflects a vector over a normal vector.</summary>
+        public static Vector3I<T> Reflect<T>(Vector3I<T> vector, Vector3I<T> normal)
+            where T : IBinaryInteger<T>
+        {
+            T dot = vector.Dot(normal);
+            return vector - (normal * (dot + dot));
+        }
+
         public static Vector3I<TSelf> Log<TSelf>(this Vector3I<TSelf> x)
             where TSelf : IBinaryInteger<TSelf>, ILogarithmicFunctions<TSelf> =>
             new(TSelf.Log(x.X), TSelf.Log(x.Y), TSelf.Log(x.Z));
diff --git a/sources/Maths/Maths/Vector4F.gen.cs b/sources/Maths/Maths/Vector4F.gen.cs
index 871162afc5..be1a8e23ed 100644
--- a/sources/Maths/Maths/Vector4F.gen.cs
+++ b/sources/Maths/Maths/Vector4F.gen.cs
@@ -3,10 +3,18 @@ namespace Silk.NET.Maths
     using System.Collections;
     using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
+    using System.Runtime.InteropServices;
+    using System.Text;
 
     partial struct Vector4F<T> :
         IEquatable<Vector4F<T>>,
-        IReadOnlyList<T>
+        IReadOnlyList<T>,
+        IFormattable,
+        IParsable<Vector4F<T>>,
+        ISpanFormattable,
+        ISpanParsable<Vector4F<T>>,
+        IUtf8SpanFormattable,
+        IUtf8SpanParsable<Vector4F<T>>
         where T : IFloatingPointIeee754<T>
     {
         /// <summary>The X component of the vector.</summary>
@@ -27,6 +35,45 @@ partial struct Vector4F<T> :
         /// <summary>Initializes the vector with individual component values.</summary>
         public Vector4F(T x, T y, T z, T w) => (X, Y, Z, W) = (x, y, z, w);
 
+        /// <summary> Initializes the vector using a <see cref="Vector2F{T}"/> for the initial elements, and the specified components for the remainder. </summary>
+        public Vector4F(Vector2F<T> other, T z, T w) => (X, Y, Z, W) = (other.X, other.Y, z, w);
+
+        /// <summary> Initializes the vector using a <see cref="Vector3F{T}"/> for the initial elements, and the specified component for the remainder. </summary>
+        public Vector4F(Vector3F<T> other, T w) => (X, Y, Z, W) = (other.X, other.Y, other.Z, w);
+
+        /// <summary>Initializes the vector from a span of 4 values.</summary>
+        public Vector4F(ReadOnlySpan<T> values)
+        {
+            if (values.Length != 4)
+                throw new ArgumentException("Input span must contain exactly 4 elements.", nameof(values));
+
+            X = values[0];
+            Y = values[1];
+            Z = values[2];
+            W = values[3];
+        }
+
+        /// <summary>Gets a vector whose 4 elements are equal to one.</summary>
+        public static Vector4F<T> One => new(Scalar<T>.One);
+
+        /// <summary>Returns a vector whose 4 elements are equal to zero.</summary>
+        public static Vector4F<T> Zero => default;
+
+        /// <summary>Gets the vector (1, 0, 0, 0).</summary>
+        public static Vector4F<T> UnitX => new(Scalar<T>.One, Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.Zero);
+
+        /// <summary>Gets the vector (0, 1, 0, 0).</summary>
+        public static Vector4F<T> UnitY => new(Scalar<T>.Zero, Scalar<T>.One, Scalar<T>.Zero, Scalar<T>.Zero);
+
+        /// <summary>Gets the vector (0, 0, 1, 0).</summary>
+        public static Vector4F<T> UnitZ => new(Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.One, Scalar<T>.Zero);
+
+        /// <summary>Gets the vector (0, 0, 0, 1).</summary>
+        public static Vector4F<T> UnitW => new(Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.One);
+
+        /// <summary>Gets the squared length of the vector (dot product with itself).</summary>
+        public T LengthSquared => Vector4F.Dot(this, this);
+
         /// <inheritdoc/>
         T IReadOnlyList<T>.this[int index] => this[index];
 
@@ -67,6 +114,243 @@ public IEnumerator<T> GetEnumerator()
             yield return W;
         }
 
+        /// <summary>Copies the components of the vector to the specified array starting at index 0.</summary>
+        public void CopyTo(T[] array) => CopyTo(array, 0);
+
+        /// <summary>Copies the components of the vector to the specified array starting at the given index.</summary>
+        public void CopyTo(T[] array, int startIndex)
+        {
+            if (array == null)
+                throw new ArgumentNullException(nameof(array));
+            if (startIndex < 0 || startIndex + 4 > array.Length)
+                throw new ArgumentOutOfRangeException(nameof(startIndex));
+
+            array[startIndex] = X;
+            array[startIndex + 1] = Y;
+            array[startIndex + 2] = Z;
+            array[startIndex + 3] = W;
+        }
+
+        /// <summary>Copies the components of the vector to the specified span starting at index 0.</summary>
+        public void CopyTo(Span<T> span) => CopyTo(span, 0);
+
+        /// <summary>Copies the components of the vector to the specified span starting at the given index.</summary>
+        public void CopyTo(Span<T> span, int startIndex)
+        {
+            if (startIndex < 0 || startIndex + 4 > span.Length)
+                throw new ArgumentOutOfRangeException(nameof(startIndex));
+
+            span[startIndex] = X;
+            span[startIndex + 1] = Y;
+            span[startIndex + 2] = Z;
+            span[startIndex + 3] = W;
+        }
+
+        /// <summary>Returns a span over the vector components.</summary>
+        public Span<T> AsSpan() => MemoryMarshal.CreateSpan(ref X, 4);
+
+        /// <summary>Formats the vector as a string.</summary>
+        public override string ToString() =>
+            $"<{X}, {Y}, {Z}, {W}>";
+
+        /// <summary>Formats the vector as a string using the specified format and format provider.</summary>
+        public string ToString(string? format, IFormatProvider? formatProvider) =>
+            $"<{X.ToString(format, formatProvider)}, {Y.ToString(format, formatProvider)}, {Z.ToString(format, formatProvider)}, {W.ToString(format, formatProvider)}>";
+
+        /// <summary>Parses a string to a <see cref="Vector4F{T}"/> instance.</summary>
+        public static Vector4F<T> Parse(string s, IFormatProvider? provider) => Parse(s.AsSpan(), provider);
+
+        /// <summary>Parses a span to a <see cref="Vector4F{T}"/> instance.</summary>
+        public static Vector4F<T> Parse(ReadOnlySpan<char> s, IFormatProvider? provider)
+        {
+            if (!TryParse(s, provider, out var result))
+                throw new FormatException("Invalid format for Vector4F.");
+
+            return result;
+        }
+
+        /// <summary>Formats the vector as a UTF-8 string using the specified format and format provider.</summary>
+        public bool TryFormat(Span<byte> utf8Destination, out int bytesWritten, ReadOnlySpan<char> format, IFormatProvider? provider)
+        {
+            Span<char> xBuffer = stackalloc char[64];
+            Span<char> yBuffer = stackalloc char[64];
+            Span<char> zBuffer = stackalloc char[64];
+            Span<char> wBuffer = stackalloc char[64];
+
+            if (!X.TryFormat(xBuffer, out int xChars, format, provider)||
+                !Y.TryFormat(yBuffer, out int yChars, format, provider)||
+                !Z.TryFormat(zBuffer, out int zChars, format, provider)||
+                !W.TryFormat(wBuffer, out int wChars, format, provider))
+            {
+                bytesWritten = 0;
+                return false;
+            }
+
+            int estimatedSize = Encoding.UTF8.GetByteCount(xBuffer[..xChars]) +
+                                Encoding.UTF8.GetByteCount(yBuffer[..yChars]) +
+                                Encoding.UTF8.GetByteCount(zBuffer[..zChars]) +
+                                Encoding.UTF8.GetByteCount(wBuffer[..wChars]) +
+                                Encoding.UTF8.GetByteCount("<, >");
+
+            if (utf8Destination.Length < estimatedSize)
+            {
+                bytesWritten = 0;
+                return false;
+            }
+
+            int totalBytes = 0;
+
+            totalBytes += Encoding.UTF8.GetBytes("<", utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(xBuffer[..xChars], utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(", ", utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(yBuffer[..yChars], utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(", ", utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(zBuffer[..zChars], utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(", ", utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(wBuffer[..wChars], utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(">", utf8Destination[totalBytes..]);
+
+            bytesWritten = totalBytes;
+            return true;
+        }
+
+        /// <summary>Formats the vector as a string using the specified format and format provider.</summary>
+        public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format, IFormatProvider? provider)
+        {
+            Span<char> xBuffer = stackalloc char[64];
+            Span<char> yBuffer = stackalloc char[64];
+            Span<char> zBuffer = stackalloc char[64];
+            Span<char> wBuffer = stackalloc char[64];
+
+            if (!X.TryFormat(xBuffer, out int xChars, format, provider) ||
+                !Y.TryFormat(yBuffer, out int yChars, format, provider) ||
+                !Z.TryFormat(zBuffer, out int zChars, format, provider) ||
+                !W.TryFormat(wBuffer, out int wChars, format, provider))
+            {
+                charsWritten = 0;
+                return false;
+            }
+
+            int requiredLength = 1 + xChars + 2 + yChars + 2 + zChars + 2 + wChars + 1;
+
+            if (destination.Length < requiredLength)
+            {
+                charsWritten = 0;
+                return false;
+            }
+
+            int pos = 0;
+            destination[pos++] = '<';
+
+            xBuffer[..xChars].CopyTo(destination[pos..]);
+            pos += xChars;
+
+            destination[pos++] = ',';
+            destination[pos++] = ' ';
+
+            yBuffer[..yChars].CopyTo(destination[pos..]);
+            pos += yChars;
+
+            destination[pos++] = ',';
+            destination[pos++] = ' ';
+
+            zBuffer[..zChars].CopyTo(destination[pos..]);
+            pos += zChars;
+
+            destination[pos++] = ',';
+            destination[pos++] = ' ';
+
+            wBuffer[..wChars].CopyTo(destination[pos..]);
+            pos += wChars;
+
+            destination[pos++] = '>';
+
+            charsWritten = pos;
+            return true;
+        }
+
+        /// <summary>Tries to parse a span to a <see cref="Vector4F{T}"/> instance.</summary>
+        public static bool TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector4F<T> result)
+        {
+            result = default;
+
+            s = s.Trim();
+            if (s.Length < 8 || s[0] != '<' || s[^1] != '>')
+                return false;
+
+            s = s[1..^1]; // Remove < and >
+
+            int commaX = s.IndexOf(',');
+            if (commaX < 0)
+                return false;
+
+            ReadOnlySpan<char> remainder1 = s.Slice(commaX + 1);
+            int commaYRelative = remainder1.IndexOf(',');
+            if (commaYRelative < 0)
+                return false;
+            int commaY = commaX + 1 + commaYRelative;
+
+            ReadOnlySpan<char> remainder2 = s.Slice(commaY + 1);
+            int commaZRelative = remainder2.IndexOf(',');
+            if (commaZRelative < 0)
+                return false;
+            int commaZ = commaY + 1 + commaZRelative;
+
+            ReadOnlySpan<char> xSpan = s[..commaX].Trim();
+            ReadOnlySpan<char> ySpan = s[(commaX + 1)..commaY].Trim();
+            ReadOnlySpan<char> zSpan = s[(commaY + 1)..commaZ].Trim();
+            ReadOnlySpan<char> wSpan = s[(commaZ + 1)..].Trim();
+
+            if (T.TryParse(xSpan, provider, out var x) &&
+                T.TryParse(ySpan, provider, out var y) &&
+                T.TryParse(zSpan, provider, out var z) &&
+                T.TryParse(wSpan, provider, out var w))
+            {
+                result = new Vector4F<T>(x, y, z, w);
+                return true;
+            }
+
+            return false;
+        }
+
+        /// <summary>Parses a UTF-8 span to a <see cref="Vector4F{T}"/> instance.</summary>
+        public static Vector4F<T> Parse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider)
+        {
+            int charCount = Encoding.UTF8.GetCharCount(utf8Text);
+            Span<char> charBuffer = charCount <= 128 ? stackalloc char[charCount] : new char[charCount];
+            Encoding.UTF8.GetChars(utf8Text, charBuffer);
+            return Parse(charBuffer, provider);
+        }
+
+        /// <summary>Tries to parse a UTF-8 span to a <see cref="Vector4F{T}"/> instance.</summary>
+        public static bool TryParse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector4F<T> result)
+        {
+            int charCount = Encoding.UTF8.GetCharCount(utf8Text);
+            Span<char> charBuffer = charCount <= 128 ? stackalloc char[charCount] : new char[charCount];
+            Encoding.UTF8.GetChars(utf8Text, charBuffer);
+            return TryParse(charBuffer, provider, out result);
+        }
+
+        /// <summary>Tries to parse a string to a <see cref="Vector4F{T}"/> instance.</summary>
+        public static bool TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector4F<T> result) =>
+            TryParse(s.AsSpan(), provider, out result);
+
+        /// <summary>Parses a span to a <see cref="Vector4F{T}"/> instance.</summary>
+        static Vector4F<T> ISpanParsable<Vector4F<T>>.Parse(ReadOnlySpan<char> s, IFormatProvider? provider) =>
+            Parse(s, provider);
+
+        /// <summary>Parses a string to a <see cref="Vector4F{T}"/> instance.</summary>
+        static Vector4F<T> IParsable<Vector4F<T>>.Parse(string s, IFormatProvider? provider) =>
+            Parse(s, provider);
+
+        /// <summary>Tries to parse a span to a <see cref="Vector4F{T}"/> instance.</summary>
+        static bool ISpanParsable<Vector4F<T>>.TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector4F<T> result) =>
+            TryParse(s, provider, out result);
+
+        /// <summary>Tries to parse a string to a <see cref="Vector4F{T}"/> instance.</summary>
+        static bool IParsable<Vector4F<T>>.TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector4F<T> result) =>
+            TryParse(s, provider, out result);
+
         /// <summary>Returns a boolean indicating whether the given two vectors are equal.</summary>
         /// <param name="left">The first vector to compare.</param>
         /// <param name="right">The second vector to compare.</param>
@@ -91,10 +375,76 @@ public IEnumerator<T> GetEnumerator()
 
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(X, Y, Z, W);
+
+        public static Vector4F<T> operator +(Vector4F<T> vector) =>
+            vector;
+
+        public static Vector4F<T> operator -(Vector4F<T> vector) =>
+            new Vector4F<T>(-vector.X, -vector.Y, -vector.Z, -vector.W);
+
+        public static Vector4F<T> operator +(Vector4F<T> left, Vector4F<T> right) =>
+            new Vector4F<T>(left.X + right.X, left.Y + right.Y, left.Z + right.Z, left.W + right.W);
+
+        public static Vector4F<T> operator -(Vector4F<T> left, Vector4F<T> right) =>
+            new Vector4F<T>(left.X - right.X, left.Y - right.Y, left.Z - right.Z, left.W - right.W);
+
+        public static Vector4F<T> operator *(Vector4F<T> left, Vector4F<T> right) =>
+            new Vector4F<T>(left.X * right.X, left.Y * right.Y, left.Z * right.Z, left.W * right.W);
+
+        public static Vector4F<T> operator /(Vector4F<T> left, Vector4F<T> right) =>
+            new Vector4F<T>(left.X / right.X, left.Y / right.Y, left.Z / right.Z, left.W / right.W);
+
+        public static Vector4F<T> operator %(Vector4F<T> left, Vector4F<T> right) =>
+            new Vector4F<T>(left.X % right.X, left.Y % right.Y, left.Z % right.Z, left.W % right.W);
+
+        public static Vector4F<T> operator +(Vector4F<T> vector, T scalar) =>
+            new Vector4F<T>(vector.X + scalar, vector.Y + scalar, vector.Z + scalar, vector.W + scalar);
+
+        public static Vector4F<T> operator -(Vector4F<T> vector, T scalar) =>
+            new Vector4F<T>(vector.X - scalar, vector.Y - scalar, vector.Z - scalar, vector.W - scalar);
+
+        public static Vector4F<T> operator *(Vector4F<T> vector, T scalar) =>
+            new Vector4F<T>(vector.X * scalar, vector.Y * scalar, vector.Z * scalar, vector.W * scalar);
+
+        public static Vector4F<T> operator *(T scalar, Vector4F<T> vector) =>
+            new Vector4F<T>(scalar * vector.X, scalar * vector.Y, scalar * vector.Z, scalar * vector.W);
+
+        public static Vector4F<T> operator /(Vector4F<T> vector, T scalar) =>
+            new Vector4F<T>(vector.X / scalar, vector.Y / scalar, vector.Z / scalar, vector.W / scalar);
+
+        public static Vector4F<T> operator %(Vector4F<T> vector, T scalar) =>
+            new Vector4F<T>(vector.X % scalar, vector.Y % scalar, vector.Z % scalar, vector.W % scalar);
+
     }
 
     static partial class Vector4F
     {
+        /// <summary>Computes the dot product of two vectors.</summary>
+        public static T Dot<T>(this Vector4F<T> left, Vector4F<T> right)
+            where T : IFloatingPointIeee754<T> =>
+            left.X * right.X + left.Y * right.Y + left.Z * right.Z + left.W * right.W;
+
+        /// <summary>Reflects a vector over a normal vector.</summary>
+        public static Vector4F<T> Reflect<T>(Vector4F<T> vector, Vector4F<T> normal)
+            where T : IFloatingPointIeee754<T>
+        {
+            T dot = vector.Dot(normal);
+            return vector - (normal * (dot + dot));
+        }
+
+        /// <summary>Computes the length of the vector.</summary>
+        public static T GetLength<T>(this Vector4F<T> vector)
+            where T : IFloatingPointIeee754<T> =>
+            T.Sqrt(vector.LengthSquared);
+
+        /// <summary>Normalizes a vector.</summary>
+        public static Vector4F<T> Normalize<T>(this Vector4F<T> vector)
+            where T : IFloatingPointIeee754<T>
+        {
+            T length = vector.GetLength();
+            return length != T.Zero ? vector / length : Vector4F<T>.Zero;
+        }
+
         public static Vector4F<TSelf> Log<TSelf>(this Vector4F<TSelf> x)
             where TSelf : IFloatingPointIeee754<TSelf>, ILogarithmicFunctions<TSelf> =>
             new(TSelf.Log(x.X), TSelf.Log(x.Y), TSelf.Log(x.Z), TSelf.Log(x.W));
diff --git a/sources/Maths/Maths/Vector4I.cs b/sources/Maths/Maths/Vector4I.cs
index 2386d7c797..16c3e21720 100644
--- a/sources/Maths/Maths/Vector4I.cs
+++ b/sources/Maths/Maths/Vector4I.cs
@@ -11,67 +11,8 @@
 namespace Silk.NET.Maths
 {
     /// <summary>A structure representing a 4D integer vector.</summary>
-    internal partial struct Vector4I<T> :
-        ISpanFormattable,
-        ISpanParsable<Vector4I<T>>,
-        IUtf8SpanFormattable,
-        IUtf8SpanParsable<Vector4I<T>>,
-        IParsable<Vector4I<T>>,
-        IFormattable
-        where T : IBinaryInteger<T>
+    internal partial struct Vector4I<T>
     {
-        /// <summary>Initializes the vector from a span of four values.</summary>
-        public Vector4I(ReadOnlySpan<T> values)
-        {
-            if (values.Length != 4)
-                throw new ArgumentException("Input span must contain exactly 4 elements.", nameof(values));
-
-            X = values[0];
-            Y = values[1];
-            Z = values[2];
-            W = values[3];
-        }
-
-        /// <summary> Initializes the vector using a Vector2I for X and Y, and a separate value for Z and W. </summary>
-        // TODO: Make sure lower dimensional constructors arent meant to zero-out the higher dimensions
-        public Vector4I(Vector2I<T> xy, T z, T w) => (X, Y, Z, W) = (xy.X, xy.Y, z, w);
-
-        /// <summary> Initializes the vector using a Vector3I for X, Y and Z, and a separate value for W. </summary>
-        public Vector4I(Vector3I<T> xyz, T w) => (X, Y, Z, W) = (xyz.X, xyz.Y, xyz.Z, w);
-
-        /// <summary>Gets a vector whose 4 elements are equal to one.</summary>
-        public static Vector4I<T> One => new(Scalar<T>.One);
-
-        /// <summary>Returns a vector whose 4 elements are equal to zero.</summary>
-        public static Vector4I<T> Zero => default;
-
-        /// <summary>Gets the vector (1, 0, 0, 0).</summary>
-        public static Vector4I<T> UnitX => new(Scalar<T>.One, Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.Zero);
-
-        /// <summary>Gets the vector (0, 1, 0, 0).</summary>
-        public static Vector4I<T> UnitY => new(Scalar<T>.Zero, Scalar<T>.One, Scalar<T>.Zero, Scalar<T>.Zero);
-
-        /// <summary>Gets the vector (0, 0, 1, 0).</summary>
-        public static Vector4I<T> UnitZ => new(Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.One, Scalar<T>.Zero);
-
-        /// <summary>Gets the vector (0, 0, 0, 1).</summary>
-        public static Vector4I<T> UnitW => new(Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.One);
-
-        /// <summary>Gets a vector with all bits set for each component.</summary>
-        public static Vector4I<T> AllBitsSet => new Vector4I<T>(T.AllBitsSet, T.AllBitsSet, T.AllBitsSet, T.AllBitsSet);
-
-        /// <summary>Gets the squared length of the vector (dot product with itself).</summary>
-        public T LengthSquared => (X * X) + (Y * Y) + (Z * Z) + (W * W);
-
-        /// <summary> Computes the dot product of this vector with another vector. </summary>
-        public T Dot(Vector4I<T> other) => (X * other.X) + (Y * other.Y) + (Z * other.Z) + (W * other.W);
-
-        /// <summary> Computes the dot product of two vectors. </summary>
-        public static T Dot(Vector4I<T> left, Vector4I<T> right) => (left.X * right.X) + (left.Y * right.Y) + (left.Z * right.Z) + (left.W * right.W);
-
-        /// <summary>Returns a span over the vector components.</summary>
-        public Span<T> AsSpan() => MemoryMarshal.CreateSpan(ref X, 4);
-
         /// <summary>Returns a vector with the component-wise maximum of this and another vector.</summary>
         public Vector4I<T> Max(Vector4I<T> other) =>
             new Vector4I<T>(T.Max(X, other.X), T.Max(Y, other.Y), T.Max(Z, other.Z), T.Max(W, other.W));
@@ -147,109 +88,6 @@ public static Vector4I<T> Clamp(Vector4I<T> vector, T min, T max) =>
         public static Vector4I<T> Abs(Vector4I<T> vector) =>
             new Vector4I<T>(T.Abs(vector.X), T.Abs(vector.Y), T.Abs(vector.Z), T.Abs(vector.W));
 
-        /// <summary>Formats the vector as a string using the specified format and format provider.</summary>
-        public string ToString(string? format, IFormatProvider? formatProvider) =>
-            $"<{X.ToString(format, formatProvider)}, {Y.ToString(format, formatProvider)}, {Z.ToString(format, formatProvider)}, {W.ToString(format, formatProvider)}>";
-
-        /// <summary>Formats the vector as a string.</summary>
-        public override string ToString() => $"<{X}, {Y}, {Z}, {W}>";
-
-        /// <summary>Formats the vector as a string using the specified format and format provider.</summary>
-        public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format, IFormatProvider? provider)
-        {
-            // Format components individually into temporary buffers
-            Span<char> xBuffer = stackalloc char[64];
-            Span<char> yBuffer = stackalloc char[64];
-            Span<char> zBuffer = stackalloc char[64];
-            Span<char> wBuffer = stackalloc char[64];
-
-            if (!X.TryFormat(xBuffer, out int xChars, format, provider) ||
-                !Y.TryFormat(yBuffer, out int yChars, format, provider) ||
-                !Z.TryFormat(zBuffer, out int zChars, format, provider) ||
-                !W.TryFormat(wBuffer, out int wChars, format, provider))
-            {
-                charsWritten = 0;
-                return false;
-            }
-
-            // Calculate total required length: < + x + ", " + y + ", " + z + ", " + w + >
-            int requiredLength = 1 + xChars + 2 + yChars + 2 + zChars + 2 + wChars + 1;
-
-            if (destination.Length < requiredLength)
-            {
-                charsWritten = 0;
-                return false;
-            }
-
-            int pos = 0;
-            destination[pos++] = '<';
-
-            xBuffer[..xChars].CopyTo(destination[pos..]);
-            pos += xChars;
-
-            destination[pos++] = ',';
-            destination[pos++] = ' ';
-
-            yBuffer[..yChars].CopyTo(destination[pos..]);
-            pos += yChars;
-
-            destination[pos++] = ',';
-            destination[pos++] = ' ';
-
-            zBuffer[..zChars].CopyTo(destination[pos..]);
-            pos += zChars;
-
-            destination[pos++] = ',';
-            destination[pos++] = ' ';
-
-            wBuffer[..wChars].CopyTo(destination[pos..]);
-            pos += wChars;
-
-            destination[pos++] = '>';
-
-            charsWritten = pos;
-            return true;
-        }
-
-        /// <summary>Parses a span to a Vector4I instance.</summary>
-        public static Vector4I<T> Parse(ReadOnlySpan<char> s, IFormatProvider? provider)
-        {
-            if (!TryParse(s, provider, out var result))
-                throw new FormatException("Invalid format for Vector4I.");
-
-            return result;
-        }
-
-        /// <summary>Copies the components of the vector to the specified array starting at index 0.</summary>
-        public void CopyTo(T[] array) => CopyTo(array, 0);
-
-        /// <summary>Copies the components of the vector to the specified array starting at the given index.</summary>
-        public void CopyTo(T[] array, int startIndex)
-        {
-            if (array == null)
-                throw new ArgumentNullException(nameof(array));
-            if (startIndex < 0 || startIndex + 4 > array.Length)
-                throw new ArgumentOutOfRangeException(nameof(startIndex));
-            array[startIndex] = X;
-            array[startIndex + 1] = Y;
-            array[startIndex + 2] = Z;
-            array[startIndex + 3] = W;
-        }
-
-        /// <summary>Copies the components of the vector to the specified span starting at index 0.</summary>
-        public void CopyTo(Span<T> span) => CopyTo(span, 0);
-
-        /// <summary>Copies the components of the vector to the specified span starting at the given index.</summary>
-        public void CopyTo(Span<T> span, int startIndex)
-        {
-            if (startIndex < 0 || startIndex + 4 > span.Length)
-                throw new ArgumentOutOfRangeException(nameof(startIndex));
-            span[startIndex] = X;
-            span[startIndex + 1] = Y;
-            span[startIndex + 2] = Z;
-            span[startIndex + 3] = W;
-        }
-
         /// <summary>Returns a vector where each component is the sign of the original vector's component.</summary>
         public Vector4I<T> Sign() =>
             new Vector4I<T>(T.CreateChecked(T.Sign(X)), T.CreateChecked(T.Sign(Y)), T.CreateChecked(T.Sign(Z)), T.CreateChecked(T.Sign(W)));
@@ -274,138 +112,6 @@ public Vector4I<T> CopySign(T signScalar) =>
         public static Vector4I<T> CopySign(Vector4I<T> value, T signScalar) =>
             new Vector4I<T>(T.CopySign(value.X, signScalar), T.CopySign(value.Y, signScalar), T.CopySign(value.Z, signScalar), T.CopySign(value.W, signScalar));
 
-        /// <summary>Parses a string to a Vector4I instance.</summary>
-        public static Vector4I<T> Parse(string s, IFormatProvider? provider) => Parse(s.AsSpan(), provider);
-
-        /// <summary>Tries to parse a span to a Vector4I instance.</summary>
-        public static bool TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector4I<T> result)
-        {
-            result = default;
-
-            s = s.Trim();
-            if (s.Length < 9 || s[0] != '<' || s[^1] != '>')
-                return false;
-
-            s = s[1..^1]; // Remove < and >
-
-            int firstComma = s.IndexOf(',');
-            if (firstComma < 0)
-                return false;
-
-            ReadOnlySpan<char> remainder1 = s.Slice(firstComma + 1);
-            int secondCommaRelative = remainder1.IndexOf(',');
-            if (secondCommaRelative < 0)
-                return false;
-            int secondComma = firstComma + 1 + secondCommaRelative;
-
-            ReadOnlySpan<char> remainder2 = s.Slice(secondComma + 1);
-            int thirdCommaRelative = remainder2.IndexOf(',');
-            if (thirdCommaRelative < 0)
-                return false;
-            int thirdComma = secondComma + 1 + thirdCommaRelative;
-
-            ReadOnlySpan<char> xSpan = s[..firstComma].Trim();
-            ReadOnlySpan<char> ySpan = s[(firstComma + 1)..secondComma].Trim();
-            ReadOnlySpan<char> zSpan = s[(secondComma + 1)..thirdComma].Trim();
-            ReadOnlySpan<char> wSpan = s[(thirdComma + 1)..].Trim();
-
-            if (T.TryParse(xSpan, provider, out var x) &&
-                T.TryParse(ySpan, provider, out var y) &&
-                T.TryParse(zSpan, provider, out var z) &&
-                T.TryParse(wSpan, provider, out var w))
-            {
-                result = new Vector4I<T>(x, y, z, w);
-                return true;
-            }
-
-            return false;
-        }
-
-        /// <summary>Tries to parse a string to a Vector4I instance.</summary>
-        public static bool TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector4I<T> result) =>
-            TryParse(s.AsSpan(), provider, out result);
-
-        /// <summary>Parses a span to a Vector4I instance.</summary>
-        static Vector4I<T> ISpanParsable<Vector4I<T>>.Parse(ReadOnlySpan<char> s, IFormatProvider? provider) =>
-            Parse(s, provider);
-
-        /// <summary>Parses a string to a Vector4I instance.</summary>
-        static Vector4I<T> IParsable<Vector4I<T>>.Parse(string s, IFormatProvider? provider) =>
-            Parse(s, provider);
-
-        /// <summary>Tries to parse a span to a Vector4I instance.</summary>
-        static bool ISpanParsable<Vector4I<T>>.TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector4I<T> result) =>
-            TryParse(s, provider, out result);
-
-        /// <summary>Tries to parse a string to a Vector4I instance.</summary>
-        static bool IParsable<Vector4I<T>>.TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector4I<T> result) =>
-            TryParse(s, provider, out result);
-
-        /// <summary>Formats the vector as a UTF-8 string using the specified format and format provider.</summary>
-        public bool TryFormat(Span<byte> utf8Destination, out int bytesWritten, ReadOnlySpan<char> format, IFormatProvider? provider)
-        {
-            // Format components individually into temporary buffers
-            Span<char> xBuffer = stackalloc char[64];
-            Span<char> yBuffer = stackalloc char[64];
-            Span<char> zBuffer = stackalloc char[64];
-            Span<char> wBuffer = stackalloc char[64];
-
-            if (!X.TryFormat(xBuffer, out int xChars, format, provider) ||
-                !Y.TryFormat(yBuffer, out int yChars, format, provider) ||
-                !Z.TryFormat(zBuffer, out int zChars, format, provider) ||
-                !W.TryFormat(wBuffer, out int wChars, format, provider))
-            {
-                bytesWritten = 0;
-                return false;
-            }
-
-            // Estimate total required UTF-8 bytes
-            int estimatedSize = Encoding.UTF8.GetByteCount(xBuffer[..xChars]) +
-                               Encoding.UTF8.GetByteCount(yBuffer[..yChars]) +
-                               Encoding.UTF8.GetByteCount(zBuffer[..zChars]) +
-                               Encoding.UTF8.GetByteCount(wBuffer[..wChars]) +
-                               Encoding.UTF8.GetByteCount("<, , , >");
-
-            if (utf8Destination.Length < estimatedSize)
-            {
-                bytesWritten = 0;
-                return false;
-            }
-
-            int totalBytes = 0;
-
-            totalBytes += Encoding.UTF8.GetBytes("<", utf8Destination[totalBytes..]);
-            totalBytes += Encoding.UTF8.GetBytes(xBuffer[..xChars], utf8Destination[totalBytes..]);
-            totalBytes += Encoding.UTF8.GetBytes(", ", utf8Destination[totalBytes..]);
-            totalBytes += Encoding.UTF8.GetBytes(yBuffer[..yChars], utf8Destination[totalBytes..]);
-            totalBytes += Encoding.UTF8.GetBytes(", ", utf8Destination[totalBytes..]);
-            totalBytes += Encoding.UTF8.GetBytes(zBuffer[..zChars], utf8Destination[totalBytes..]);
-            totalBytes += Encoding.UTF8.GetBytes(", ", utf8Destination[totalBytes..]);
-            totalBytes += Encoding.UTF8.GetBytes(wBuffer[..wChars], utf8Destination[totalBytes..]);
-            totalBytes += Encoding.UTF8.GetBytes(">", utf8Destination[totalBytes..]);
-
-            bytesWritten = totalBytes;
-            return true;
-        }
-
-        /// <summary>Parses a UTF-8 span to a Vector4I instance.</summary>
-        public static Vector4I<T> Parse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider)
-        {
-            int charCount = Encoding.UTF8.GetCharCount(utf8Text);
-            Span<char> charBuffer = charCount <= 128 ? stackalloc char[charCount] : new char[charCount];
-            Encoding.UTF8.GetChars(utf8Text, charBuffer);
-            return Parse(charBuffer, provider);
-        }
-
-        /// <summary>Tries to parse a UTF-8 span to a Vector4I instance.</summary>
-        public static bool TryParse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector4I<T> result)
-        {
-            int charCount = Encoding.UTF8.GetCharCount(utf8Text);
-            Span<char> charBuffer = charCount <= 128 ? stackalloc char[charCount] : new char[charCount];
-            Encoding.UTF8.GetChars(utf8Text, charBuffer);
-            return TryParse(charBuffer, provider, out result);
-        }
-
         // Casts
 
         /// <summary>Explicitly casts a System.Numerics.Vector4 to a Vector4I.</summary>
@@ -416,77 +122,6 @@ public static explicit operator Vector4I<T>(System.Numerics.Vector4 v) =>
         public static explicit operator System.Numerics.Vector4(Vector4I<T> v) =>
             new System.Numerics.Vector4(Convert.ToSingle(v.X), Convert.ToSingle(v.Y), Convert.ToSingle(v.Z), Convert.ToSingle(v.W));
 
-        // Component Operators
-        public static Vector4I<T> operator +(Vector4I<T> left, Vector4I<T> right) =>
-            new Vector4I<T>(left.X + right.X, left.Y + right.Y, left.Z + right.Z, left.W + right.W);
-
-        public static Vector4I<T> operator -(Vector4I<T> left, Vector4I<T> right) =>
-            new Vector4I<T>(left.X - right.X, left.Y - right.Y, left.Z - right.Z, left.W - right.W);
-
-        public static Vector4I<T> operator *(Vector4I<T> left, Vector4I<T> right) =>
-            new Vector4I<T>(left.X * right.X, left.Y * right.Y, left.Z * right.Z, left.W * right.W);
-
-        public static Vector4I<T> operator /(Vector4I<T> left, Vector4I<T> right) =>
-            new Vector4I<T>(left.X / right.X, left.Y / right.Y, left.Z / right.Z, left.W / right.W);
-
-        public static Vector4I<T> operator %(Vector4I<T> left, Vector4I<T> right) =>
-            new Vector4I<T>(left.X % right.X, left.Y % right.Y, left.Z % right.Z, left.W % right.W);
-
-        // Scalar Operators
-        public static Vector4I<T> operator +(Vector4I<T> vector, T scalar) =>
-            new Vector4I<T>(vector.X + scalar, vector.Y + scalar, vector.Z + scalar, vector.W + scalar);
-
-        public static Vector4I<T> operator -(Vector4I<T> vector, T scalar) =>
-            new Vector4I<T>(vector.X - scalar, vector.Y - scalar, vector.Z - scalar, vector.W - scalar);
-
-        public static Vector4I<T> operator *(Vector4I<T> vector, T scalar) =>
-            new Vector4I<T>(vector.X * scalar, vector.Y * scalar, vector.Z * scalar, vector.W * scalar);
-
-        public static Vector4I<T> operator /(Vector4I<T> vector, T scalar) =>
-            new Vector4I<T>(vector.X / scalar, vector.Y / scalar, vector.Z / scalar, vector.W / scalar);
-
-        public static Vector4I<T> operator %(Vector4I<T> vector, T scalar) =>
-            new Vector4I<T>(vector.X % scalar, vector.Y % scalar, vector.Z % scalar, vector.W % scalar);
-
-        // + operator: returns the vector (?)
-        public static Vector4I<T> operator +(Vector4I<T> vector) => vector;
-
-        //  - operator: returns the negated vector
-        public static Vector4I<T> operator -(Vector4I<T> vector) =>
-            new Vector4I<T>(-vector.X, -vector.Y, -vector.Z, -vector.W);
-
-        // Bitwise Operators
-        public static Vector4I<T> operator &(Vector4I<T> left, Vector4I<T> right) =>
-            new Vector4I<T>(left.X & right.X, left.Y & right.Y, left.Z & right.Z, left.W & right.W);
-
-        public static Vector4I<T> operator |(Vector4I<T> left, Vector4I<T> right) =>
-            new Vector4I<T>(left.X | right.X, left.Y | right.Y, left.Z | right.Z, left.W | right.W);
-
-        public static Vector4I<T> operator ^(Vector4I<T> left, Vector4I<T> right) =>
-            new Vector4I<T>(left.X ^ right.X, left.Y ^ right.Y, left.Z ^ right.Z, left.W ^ right.W);
-
-        public static Vector4I<T> operator &(Vector4I<T> vector, T scalar) =>
-            new Vector4I<T>(vector.X & scalar, vector.Y & scalar, vector.Z & scalar, vector.W & scalar);
-
-        public static Vector4I<T> operator &(T scalar, Vector4I<T> vector) =>
-            new Vector4I<T>(scalar & vector.X, scalar & vector.Y, scalar & vector.Z, scalar & vector.W);
-
-        public static Vector4I<T> operator |(Vector4I<T> vector, T scalar) =>
-            new Vector4I<T>(vector.X | scalar, vector.Y | scalar, vector.Z | scalar, vector.W | scalar);
-
-        public static Vector4I<T> operator |(T scalar, Vector4I<T> vector) =>
-            new Vector4I<T>(scalar | vector.X, scalar | vector.Y, scalar | vector.Z, scalar | vector.W);
-
-        public static Vector4I<T> operator ^(Vector4I<T> vector, T scalar) =>
-            new Vector4I<T>(vector.X ^ scalar, vector.Y ^ scalar, vector.Z ^ scalar, vector.W ^ scalar);
-
-        public static Vector4I<T> operator ^(T scalar, Vector4I<T> vector) =>
-            new Vector4I<T>(scalar ^ vector.X, scalar ^ vector.Y, scalar ^ vector.Z, scalar ^ vector.W);
-
-        // NOT operator
-        public static Vector4I<T> operator ~(Vector4I<T> vector) =>
-            new Vector4I<T>(~vector.X, ~vector.Y, ~vector.Z, ~vector.W);
-
         // IBinaryInteger
         public static Vector4I<T> Log2(Vector4I<T> x) =>
             new Vector4I<T>(T.Log2(x.X), T.Log2(x.Y), T.Log2(x.Z), T.Log2(x.W));
diff --git a/sources/Maths/Maths/Vector4I.gen.cs b/sources/Maths/Maths/Vector4I.gen.cs
index ef2d344376..04eb7ca61c 100644
--- a/sources/Maths/Maths/Vector4I.gen.cs
+++ b/sources/Maths/Maths/Vector4I.gen.cs
@@ -3,10 +3,18 @@ namespace Silk.NET.Maths
     using System.Collections;
     using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
+    using System.Runtime.InteropServices;
+    using System.Text;
 
     partial struct Vector4I<T> :
         IEquatable<Vector4I<T>>,
-        IReadOnlyList<T>
+        IReadOnlyList<T>,
+        IFormattable,
+        IParsable<Vector4I<T>>,
+        ISpanFormattable,
+        ISpanParsable<Vector4I<T>>,
+        IUtf8SpanFormattable,
+        IUtf8SpanParsable<Vector4I<T>>
         where T : IBinaryInteger<T>
     {
         /// <summary>The X component of the vector.</summary>
@@ -27,6 +35,48 @@ partial struct Vector4I<T> :
         /// <summary>Initializes the vector with individual component values.</summary>
         public Vector4I(T x, T y, T z, T w) => (X, Y, Z, W) = (x, y, z, w);
 
+        /// <summary> Initializes the vector using a <see cref="Vector2I{T}"/> for the initial elements, and the specified components for the remainder. </summary>
+        public Vector4I(Vector2I<T> other, T z, T w) => (X, Y, Z, W) = (other.X, other.Y, z, w);
+
+        /// <summary> Initializes the vector using a <see cref="Vector3I{T}"/> for the initial elements, and the specified component for the remainder. </summary>
+        public Vector4I(Vector3I<T> other, T w) => (X, Y, Z, W) = (other.X, other.Y, other.Z, w);
+
+        /// <summary>Initializes the vector from a span of 4 values.</summary>
+        public Vector4I(ReadOnlySpan<T> values)
+        {
+            if (values.Length != 4)
+                throw new ArgumentException("Input span must contain exactly 4 elements.", nameof(values));
+
+            X = values[0];
+            Y = values[1];
+            Z = values[2];
+            W = values[3];
+        }
+
+        /// <summary>Gets a vector whose 4 elements are equal to one.</summary>
+        public static Vector4I<T> One => new(Scalar<T>.One);
+
+        /// <summary>Returns a vector whose 4 elements are equal to zero.</summary>
+        public static Vector4I<T> Zero => default;
+
+        /// <summary>Gets the vector (1, 0, 0, 0).</summary>
+        public static Vector4I<T> UnitX => new(Scalar<T>.One, Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.Zero);
+
+        /// <summary>Gets the vector (0, 1, 0, 0).</summary>
+        public static Vector4I<T> UnitY => new(Scalar<T>.Zero, Scalar<T>.One, Scalar<T>.Zero, Scalar<T>.Zero);
+
+        /// <summary>Gets the vector (0, 0, 1, 0).</summary>
+        public static Vector4I<T> UnitZ => new(Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.One, Scalar<T>.Zero);
+
+        /// <summary>Gets the vector (0, 0, 0, 1).</summary>
+        public static Vector4I<T> UnitW => new(Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.One);
+
+        /// <summary>Gets a vector with all bits set for each component.</summary>
+        public static Vector4I<T> AllBitsSet => new Vector4I<T>(T.AllBitsSet, T.AllBitsSet, T.AllBitsSet, T.AllBitsSet);
+
+        /// <summary>Gets the squared length of the vector (dot product with itself).</summary>
+        public T LengthSquared => Vector4I.Dot(this, this);
+
         /// <inheritdoc/>
         T IReadOnlyList<T>.this[int index] => this[index];
 
@@ -67,6 +117,243 @@ public IEnumerator<T> GetEnumerator()
             yield return W;
         }
 
+        /// <summary>Copies the components of the vector to the specified array starting at index 0.</summary>
+        public void CopyTo(T[] array) => CopyTo(array, 0);
+
+        /// <summary>Copies the components of the vector to the specified array starting at the given index.</summary>
+        public void CopyTo(T[] array, int startIndex)
+        {
+            if (array == null)
+                throw new ArgumentNullException(nameof(array));
+            if (startIndex < 0 || startIndex + 4 > array.Length)
+                throw new ArgumentOutOfRangeException(nameof(startIndex));
+
+            array[startIndex] = X;
+            array[startIndex + 1] = Y;
+            array[startIndex + 2] = Z;
+            array[startIndex + 3] = W;
+        }
+
+        /// <summary>Copies the components of the vector to the specified span starting at index 0.</summary>
+        public void CopyTo(Span<T> span) => CopyTo(span, 0);
+
+        /// <summary>Copies the components of the vector to the specified span starting at the given index.</summary>
+        public void CopyTo(Span<T> span, int startIndex)
+        {
+            if (startIndex < 0 || startIndex + 4 > span.Length)
+                throw new ArgumentOutOfRangeException(nameof(startIndex));
+
+            span[startIndex] = X;
+            span[startIndex + 1] = Y;
+            span[startIndex + 2] = Z;
+            span[startIndex + 3] = W;
+        }
+
+        /// <summary>Returns a span over the vector components.</summary>
+        public Span<T> AsSpan() => MemoryMarshal.CreateSpan(ref X, 4);
+
+        /// <summary>Formats the vector as a string.</summary>
+        public override string ToString() =>
+            $"<{X}, {Y}, {Z}, {W}>";
+
+        /// <summary>Formats the vector as a string using the specified format and format provider.</summary>
+        public string ToString(string? format, IFormatProvider? formatProvider) =>
+            $"<{X.ToString(format, formatProvider)}, {Y.ToString(format, formatProvider)}, {Z.ToString(format, formatProvider)}, {W.ToString(format, formatProvider)}>";
+
+        /// <summary>Parses a string to a <see cref="Vector4I{T}"/> instance.</summary>
+        public static Vector4I<T> Parse(string s, IFormatProvider? provider) => Parse(s.AsSpan(), provider);
+
+        /// <summary>Parses a span to a <see cref="Vector4I{T}"/> instance.</summary>
+        public static Vector4I<T> Parse(ReadOnlySpan<char> s, IFormatProvider? provider)
+        {
+            if (!TryParse(s, provider, out var result))
+                throw new FormatException("Invalid format for Vector4I.");
+
+            return result;
+        }
+
+        /// <summary>Formats the vector as a UTF-8 string using the specified format and format provider.</summary>
+        public bool TryFormat(Span<byte> utf8Destination, out int bytesWritten, ReadOnlySpan<char> format, IFormatProvider? provider)
+        {
+            Span<char> xBuffer = stackalloc char[64];
+            Span<char> yBuffer = stackalloc char[64];
+            Span<char> zBuffer = stackalloc char[64];
+            Span<char> wBuffer = stackalloc char[64];
+
+            if (!X.TryFormat(xBuffer, out int xChars, format, provider)||
+                !Y.TryFormat(yBuffer, out int yChars, format, provider)||
+                !Z.TryFormat(zBuffer, out int zChars, format, provider)||
+                !W.TryFormat(wBuffer, out int wChars, format, provider))
+            {
+                bytesWritten = 0;
+                return false;
+            }
+
+            int estimatedSize = Encoding.UTF8.GetByteCount(xBuffer[..xChars]) +
+                                Encoding.UTF8.GetByteCount(yBuffer[..yChars]) +
+                                Encoding.UTF8.GetByteCount(zBuffer[..zChars]) +
+                                Encoding.UTF8.GetByteCount(wBuffer[..wChars]) +
+                                Encoding.UTF8.GetByteCount("<, >");
+
+            if (utf8Destination.Length < estimatedSize)
+            {
+                bytesWritten = 0;
+                return false;
+            }
+
+            int totalBytes = 0;
+
+            totalBytes += Encoding.UTF8.GetBytes("<", utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(xBuffer[..xChars], utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(", ", utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(yBuffer[..yChars], utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(", ", utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(zBuffer[..zChars], utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(", ", utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(wBuffer[..wChars], utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(">", utf8Destination[totalBytes..]);
+
+            bytesWritten = totalBytes;
+            return true;
+        }
+
+        /// <summary>Formats the vector as a string using the specified format and format provider.</summary>
+        public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format, IFormatProvider? provider)
+        {
+            Span<char> xBuffer = stackalloc char[64];
+            Span<char> yBuffer = stackalloc char[64];
+            Span<char> zBuffer = stackalloc char[64];
+            Span<char> wBuffer = stackalloc char[64];
+
+            if (!X.TryFormat(xBuffer, out int xChars, format, provider) ||
+                !Y.TryFormat(yBuffer, out int yChars, format, provider) ||
+                !Z.TryFormat(zBuffer, out int zChars, format, provider) ||
+                !W.TryFormat(wBuffer, out int wChars, format, provider))
+            {
+                charsWritten = 0;
+                return false;
+            }
+
+            int requiredLength = 1 + xChars + 2 + yChars + 2 + zChars + 2 + wChars + 1;
+
+            if (destination.Length < requiredLength)
+            {
+                charsWritten = 0;
+                return false;
+            }
+
+            int pos = 0;
+            destination[pos++] = '<';
+
+            xBuffer[..xChars].CopyTo(destination[pos..]);
+            pos += xChars;
+
+            destination[pos++] = ',';
+            destination[pos++] = ' ';
+
+            yBuffer[..yChars].CopyTo(destination[pos..]);
+            pos += yChars;
+
+            destination[pos++] = ',';
+            destination[pos++] = ' ';
+
+            zBuffer[..zChars].CopyTo(destination[pos..]);
+            pos += zChars;
+
+            destination[pos++] = ',';
+            destination[pos++] = ' ';
+
+            wBuffer[..wChars].CopyTo(destination[pos..]);
+            pos += wChars;
+
+            destination[pos++] = '>';
+
+            charsWritten = pos;
+            return true;
+        }
+
+        /// <summary>Tries to parse a span to a <see cref="Vector4I{T}"/> instance.</summary>
+        public static bool TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector4I<T> result)
+        {
+            result = default;
+
+            s = s.Trim();
+            if (s.Length < 8 || s[0] != '<' || s[^1] != '>')
+                return false;
+
+            s = s[1..^1]; // Remove < and >
+
+            int commaX = s.IndexOf(',');
+            if (commaX < 0)
+                return false;
+
+            ReadOnlySpan<char> remainder1 = s.Slice(commaX + 1);
+            int commaYRelative = remainder1.IndexOf(',');
+            if (commaYRelative < 0)
+                return false;
+            int commaY = commaX + 1 + commaYRelative;
+
+            ReadOnlySpan<char> remainder2 = s.Slice(commaY + 1);
+            int commaZRelative = remainder2.IndexOf(',');
+            if (commaZRelative < 0)
+                return false;
+            int commaZ = commaY + 1 + commaZRelative;
+
+            ReadOnlySpan<char> xSpan = s[..commaX].Trim();
+            ReadOnlySpan<char> ySpan = s[(commaX + 1)..commaY].Trim();
+            ReadOnlySpan<char> zSpan = s[(commaY + 1)..commaZ].Trim();
+            ReadOnlySpan<char> wSpan = s[(commaZ + 1)..].Trim();
+
+            if (T.TryParse(xSpan, provider, out var x) &&
+                T.TryParse(ySpan, provider, out var y) &&
+                T.TryParse(zSpan, provider, out var z) &&
+                T.TryParse(wSpan, provider, out var w))
+            {
+                result = new Vector4I<T>(x, y, z, w);
+                return true;
+            }
+
+            return false;
+        }
+
+        /// <summary>Parses a UTF-8 span to a <see cref="Vector4I{T}"/> instance.</summary>
+        public static Vector4I<T> Parse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider)
+        {
+            int charCount = Encoding.UTF8.GetCharCount(utf8Text);
+            Span<char> charBuffer = charCount <= 128 ? stackalloc char[charCount] : new char[charCount];
+            Encoding.UTF8.GetChars(utf8Text, charBuffer);
+            return Parse(charBuffer, provider);
+        }
+
+        /// <summary>Tries to parse a UTF-8 span to a <see cref="Vector4I{T}"/> instance.</summary>
+        public static bool TryParse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector4I<T> result)
+        {
+            int charCount = Encoding.UTF8.GetCharCount(utf8Text);
+            Span<char> charBuffer = charCount <= 128 ? stackalloc char[charCount] : new char[charCount];
+            Encoding.UTF8.GetChars(utf8Text, charBuffer);
+            return TryParse(charBuffer, provider, out result);
+        }
+
+        /// <summary>Tries to parse a string to a <see cref="Vector4I{T}"/> instance.</summary>
+        public static bool TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector4I<T> result) =>
+            TryParse(s.AsSpan(), provider, out result);
+
+        /// <summary>Parses a span to a <see cref="Vector4I{T}"/> instance.</summary>
+        static Vector4I<T> ISpanParsable<Vector4I<T>>.Parse(ReadOnlySpan<char> s, IFormatProvider? provider) =>
+            Parse(s, provider);
+
+        /// <summary>Parses a string to a <see cref="Vector4I{T}"/> instance.</summary>
+        static Vector4I<T> IParsable<Vector4I<T>>.Parse(string s, IFormatProvider? provider) =>
+            Parse(s, provider);
+
+        /// <summary>Tries to parse a span to a <see cref="Vector4I{T}"/> instance.</summary>
+        static bool ISpanParsable<Vector4I<T>>.TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector4I<T> result) =>
+            TryParse(s, provider, out result);
+
+        /// <summary>Tries to parse a string to a <see cref="Vector4I{T}"/> instance.</summary>
+        static bool IParsable<Vector4I<T>>.TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector4I<T> result) =>
+            TryParse(s, provider, out result);
+
         /// <summary>Returns a boolean indicating whether the given two vectors are equal.</summary>
         /// <param name="left">The first vector to compare.</param>
         /// <param name="right">The second vector to compare.</param>
@@ -91,10 +378,92 @@ public IEnumerator<T> GetEnumerator()
 
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(X, Y, Z, W);
+
+        public static Vector4I<T> operator +(Vector4I<T> vector) =>
+            vector;
+
+        public static Vector4I<T> operator -(Vector4I<T> vector) =>
+            new Vector4I<T>(-vector.X, -vector.Y, -vector.Z, -vector.W);
+
+        public static Vector4I<T> operator +(Vector4I<T> left, Vector4I<T> right) =>
+            new Vector4I<T>(left.X + right.X, left.Y + right.Y, left.Z + right.Z, left.W + right.W);
+
+        public static Vector4I<T> operator -(Vector4I<T> left, Vector4I<T> right) =>
+            new Vector4I<T>(left.X - right.X, left.Y - right.Y, left.Z - right.Z, left.W - right.W);
+
+        public static Vector4I<T> operator *(Vector4I<T> left, Vector4I<T> right) =>
+            new Vector4I<T>(left.X * right.X, left.Y * right.Y, left.Z * right.Z, left.W * right.W);
+
+        public static Vector4I<T> operator /(Vector4I<T> left, Vector4I<T> right) =>
+            new Vector4I<T>(left.X / right.X, left.Y / right.Y, left.Z / right.Z, left.W / right.W);
+
+        public static Vector4I<T> operator %(Vector4I<T> left, Vector4I<T> right) =>
+            new Vector4I<T>(left.X % right.X, left.Y % right.Y, left.Z % right.Z, left.W % right.W);
+
+        public static Vector4I<T> operator +(Vector4I<T> vector, T scalar) =>
+            new Vector4I<T>(vector.X + scalar, vector.Y + scalar, vector.Z + scalar, vector.W + scalar);
+
+        public static Vector4I<T> operator -(Vector4I<T> vector, T scalar) =>
+            new Vector4I<T>(vector.X - scalar, vector.Y - scalar, vector.Z - scalar, vector.W - scalar);
+
+        public static Vector4I<T> operator *(Vector4I<T> vector, T scalar) =>
+            new Vector4I<T>(vector.X * scalar, vector.Y * scalar, vector.Z * scalar, vector.W * scalar);
+
+        public static Vector4I<T> operator *(T scalar, Vector4I<T> vector) =>
+            new Vector4I<T>(scalar * vector.X, scalar * vector.Y, scalar * vector.Z, scalar * vector.W);
+
+        public static Vector4I<T> operator /(Vector4I<T> vector, T scalar) =>
+            new Vector4I<T>(vector.X / scalar, vector.Y / scalar, vector.Z / scalar, vector.W / scalar);
+
+        public static Vector4I<T> operator %(Vector4I<T> vector, T scalar) =>
+            new Vector4I<T>(vector.X % scalar, vector.Y % scalar, vector.Z % scalar, vector.W % scalar);
+
+        public static Vector4I<T> operator ~(Vector4I<T> vector) =>
+            new Vector4I<T>(~vector.X, ~vector.Y, ~vector.Z, ~vector.W);
+
+        public static Vector4I<T> operator &(Vector4I<T> left, Vector4I<T> right) =>
+            new Vector4I<T>(left.X & right.X, left.Y & right.Y, left.Z & right.Z, left.W & right.W);
+
+        public static Vector4I<T> operator |(Vector4I<T> left, Vector4I<T> right) =>
+            new Vector4I<T>(left.X | right.X, left.Y | right.Y, left.Z | right.Z, left.W | right.W);
+
+        public static Vector4I<T> operator ^(Vector4I<T> left, Vector4I<T> right) =>
+            new Vector4I<T>(left.X ^ right.X, left.Y ^ right.Y, left.Z ^ right.Z, left.W ^ right.W);
+
+        public static Vector4I<T> operator &(Vector4I<T> vector, T scalar) =>
+            new Vector4I<T>(vector.X & scalar, vector.Y & scalar, vector.Z & scalar, vector.W & scalar);
+
+        public static Vector4I<T> operator &(T scalar, Vector4I<T> vector) =>
+            new Vector4I<T>(scalar & vector.X, scalar & vector.Y, scalar & vector.Z, scalar & vector.W);
+
+        public static Vector4I<T> operator |(Vector4I<T> vector, T scalar) =>
+            new Vector4I<T>(vector.X | scalar, vector.Y | scalar, vector.Z | scalar, vector.W | scalar);
+
+        public static Vector4I<T> operator |(T scalar, Vector4I<T> vector) =>
+            new Vector4I<T>(scalar | vector.X, scalar | vector.Y, scalar | vector.Z, scalar | vector.W);
+
+        public static Vector4I<T> operator ^(Vector4I<T> vector, T scalar) =>
+            new Vector4I<T>(vector.X ^ scalar, vector.Y ^ scalar, vector.Z ^ scalar, vector.W ^ scalar);
+
+        public static Vector4I<T> operator ^(T scalar, Vector4I<T> vector) =>
+            new Vector4I<T>(scalar ^ vector.X, scalar ^ vector.Y, scalar ^ vector.Z, scalar ^ vector.W);
     }
 
     static partial class Vector4I
     {
+        /// <summary>Computes the dot product of two vectors.</summary>
+        public static T Dot<T>(this Vector4I<T> left, Vector4I<T> right)
+            where T : IBinaryInteger<T> =>
+            left.X * right.X + left.Y * right.Y + left.Z * right.Z + left.W * right.W;
+
+        /// <summary>Reflects a vector over a normal vector.</summary>
+        public static Vector4I<T> Reflect<T>(Vector4I<T> vector, Vector4I<T> normal)
+            where T : IBinaryInteger<T>
+        {
+            T dot = vector.Dot(normal);
+            return vector - (normal * (dot + dot));
+        }
+
         public static Vector4I<TSelf> Log<TSelf>(this Vector4I<TSelf> x)
             where TSelf : IBinaryInteger<TSelf>, ILogarithmicFunctions<TSelf> =>
             new(TSelf.Log(x.X), TSelf.Log(x.Y), TSelf.Log(x.Z), TSelf.Log(x.W));