diff --git a/SHADE_Managed/src/Graphics/Color.cxx b/SHADE_Managed/src/Graphics/Color.cxx
new file mode 100644
index 00000000..cf1fff47
--- /dev/null
+++ b/SHADE_Managed/src/Graphics/Color.cxx
@@ -0,0 +1,154 @@
+/************************************************************************************//*!
+\file           Color.cxx
+\author         Tng Kah Wei, kahwei.tng, 390009620
+\par            email: kahwei.tng\@digipen.edu
+\date           Nov 3, 2021
+\brief          Contains the definition of the functions of the managed Color struct.
+
+                Note: This file is written in C++17/CLI.
+ 
+Copyright (C) 2021 DigiPen Institute of Technology.
+Reproduction or disclosure of this file or its contents without the prior written consent 
+of DigiPen Institute of Technology is prohibited.
+*//*************************************************************************************/
+// Precompiled Headers
+#include "SHpch.h"
+// Primary Header
+#include "Graphics/Color.hxx"
+// Standard Libraries
+#include <algorithm>
+// Project Includes
+#include "Math/Math.hxx"
+
+namespace SHADE
+{
+    /*---------------------------------------------------------------------------------*/
+    /* Constructors                                                                    */
+    /*---------------------------------------------------------------------------------*/
+    Color::Color(float _red)
+    : Color { _red, 0.0f, 0.0f, 1.0f }
+    {}
+    Color::Color(float _red, float _green)
+    : Color { _red, _green, 0.0f, 1.0f }
+    {}
+    Color::Color(float _red, float _green, float _blue)
+    : Color { _red, _green, _blue, 1.0f }
+    {}
+    Color::Color(float _red, float _green, float _blue, float _alpha)
+    : r { _red }
+    , g { _green }
+    , b { _blue }
+    , a { _alpha }
+    {}
+    
+    /*---------------------------------------------------------------------------------*/
+    /* IEquatable                                                                      */
+    /*---------------------------------------------------------------------------------*/
+    bool Color::Equals(Object^ o)
+    {
+        try
+        {
+            Color col = safe_cast<Color>(o);
+            return Equals(col);
+        }
+        catch (System::InvalidCastException^)
+        {
+            return false;
+        }
+    }
+
+    /*---------------------------------------------------------------------------------*/
+    /* Object Overrides                                                                */
+    /*---------------------------------------------------------------------------------*/
+    bool Color::Equals(Color other)
+    {
+        return Math::CompareFloat(this->r, other.r)
+               &&
+               Math::CompareFloat(this->g, other.g)
+               &&
+               Math::CompareFloat(this->b, other.b)
+               &&
+               Math::CompareFloat(this->a, other.a);
+    }
+    int Color::GetHashCode()
+    {
+        const int HASH = 19;
+        const int HASH2 = 23;
+        const int HASH3 = 29;
+        return r.GetHashCode() * HASH
+             + g.GetHashCode() * HASH2
+             + b.GetHashCode() * HASH3
+             + a.GetHashCode();
+    }
+
+    /*---------------------------------------------------------------------------------*/
+    /* Static Functions                                                                */
+    /*---------------------------------------------------------------------------------*/
+    Color Color::Lerp(Color colA, Color colB, float t)
+    {
+        return LerpUnclamped(colA, colB, std::clamp(t, 0.0f, 1.0f));
+    }
+
+    Color Color::LerpUnclamped(Color colA, Color colB, float t)
+    {
+        return colA + ((colB - colA) * t);
+    }
+    Color Color::operator+(Color lhs, Color rhs)
+    {
+        return Color
+        (
+            lhs.r + rhs.r,
+            lhs.g + rhs.g,
+            lhs.b + rhs.b,
+            lhs.a + rhs.a
+        );
+    }
+    Color Color::operator-(Color lhs, Color rhs)
+    {
+        return Color
+        (
+            lhs.r - rhs.r,
+            lhs.g - rhs.g,
+            lhs.b - rhs.b,
+            lhs.a - rhs.a
+        );
+    }
+    Color Color::operator*(Color lhs, Color rhs)
+    {
+        return Color
+        (
+            lhs.r * rhs.r,
+            lhs.g * rhs.g,
+            lhs.b * rhs.b,
+            lhs.a * rhs.a
+        );
+    }
+    Color Color::operator*(Color lhs, float rhs)
+    {
+        return Color
+        (
+            lhs.r * rhs,
+            lhs.g * rhs,
+            lhs.b * rhs,
+            lhs.a * rhs
+        );
+    }
+    Color Color::operator/(Color lhs, float rhs)
+    {
+        return Color
+        (
+            lhs.r / rhs,
+            lhs.g / rhs,
+            lhs.b / rhs,
+            lhs.a / rhs
+        );
+    }
+    bool Color::operator==(Color lhs, Color rhs)
+    {
+        return lhs.Equals(rhs);
+    }
+    bool Color::operator!=(Color lhs, Color rhs)
+    {
+        return !(lhs == rhs);
+    }
+} 
diff --git a/SHADE_Managed/src/Graphics/Color.hxx b/SHADE_Managed/src/Graphics/Color.hxx
new file mode 100644
index 00000000..d6a46216
--- /dev/null
+++ b/SHADE_Managed/src/Graphics/Color.hxx
@@ -0,0 +1,287 @@
+/************************************************************************************//*!
+\file           Color.hxx
+\author         Tng Kah Wei, kahwei.tng, 390009620
+\par            email: kahwei.tng\@digipen.edu
+\date           Oct 28, 2022
+\brief          Contains the definition of the managed Color struct with the
+                declaration of functions for working with it.
+                
+                Note: This file is written in C++17/CLI.
+ 
+Copyright (C) 2022 DigiPen Institute of Technology.
+Reproduction or disclosure of this file or its contents without the prior written consent 
+of DigiPen Institute of Technology is prohibited.
+*//*************************************************************************************/
+#pragma once
+
+namespace SHADE
+{
+    /// <summary>
+    /// CLR version of the the SHADE Engine's Color struct which describes a Color
+    /// encoded using floating point numbers that range from 0.0f to 1.0f.
+    /// </summary>
+    [System::Runtime::InteropServices::StructLayout(System::Runtime::InteropServices::LayoutKind::Sequential)]
+    public value struct Color : public System::IEquatable<Color>
+    {
+      public:
+        /*-----------------------------------------------------------------------------*/
+        /* Type Definitions                                                            */
+        /*-----------------------------------------------------------------------------*/
+        /// <summary>
+        /// A static class that contains a set of default Colors.
+        /// </summary>
+        ref class Defaults abstract sealed
+        {
+          public:
+            /*-------------------------------------------------------------------------*/
+            /* Properties                                                              */
+            /*-------------------------------------------------------------------------*/
+            /// <summary>
+            /// Pure black.
+            /// </summary>
+            static property Color Black
+            {
+                Color get()  { return Color(0.0f, 0.0f, 0.0f); }
+            }
+            /// <summary>
+            /// Light Gray, lighter than gray.
+            /// </summary>
+            static property Color LightGray
+            {
+                Color get() { return Color(0.827451f, 0.827451f, 0.827451f); }
+            }
+            /// <summary>
+            /// Gray, halfway between black and white.
+            /// </summary>
+            static property Color Gray
+            {
+                Color get()  { return Color(0.5f, 0.5f, 0.5f); }
+            }
+            /// <summary>
+            /// Dark Gray, darker than gray.
+            /// </summary>
+            static property Color DarkGray
+            {
+                Color get()  { return Color(0.622f, 0.622f, 0.622f); }
+            }
+            /// <summary>
+            /// Pure white.
+            /// </summary>
+            static property Color White
+            {
+                Color get()  { return Color(1.0f, 1.0f, 1.0f); }
+            }
+            /// <summary>
+            /// Pure red.
+            /// </summary>
+            static property Color Red
+            {
+                Color get()  { return Color(1.0f, 0.0f, 0.0f); }
+            }
+            /// <summary>
+            /// Pure green.
+            /// </summary>
+            static property Color Green
+            {
+                Color get()  { return Color(0.0f, 1.0f, 0.0f); }
+            }
+            /// <summary>
+            /// Pure blue.
+            /// </summary>
+            static property Color Blue
+            {
+                Color get()  { return Color(0.0f, 0.0f, 1.0f); }
+            }
+            /// <summary>
+            /// Pure cyan, mix of pure green and blue.
+            /// </summary>
+            static property Color Cyan
+            {
+                Color get()  { return Color(0.0f, 1.0f, 1.0f); }
+            }
+            /// <summary>
+            /// Pure magenta, mix of pure red and blue.
+            /// </summary>
+            static property Color Magenta
+            {
+                Color get()  { return Color(1.0f, 0.0f, 1.0f); }
+            }
+            /// <summary>
+            /// Pure yellow, mix of pure red and green.
+            /// </summary>
+            static property Color Yellow
+            {
+                Color get()  { return Color(1.0f, 1.0f, 0.0f); }
+            }
+        };
+
+        /*-----------------------------------------------------------------------------*/
+        /* Constructors                                                                */
+        /*-----------------------------------------------------------------------------*/
+        /// <summary>
+        /// Constructor to construct a Color with the specified components with the
+        /// green, blue and alpha component set to 1.0f.
+        /// </summary>
+        /// <param name="_red">Red component to set.</param>
+        Color(float _red);
+        /// <summary>
+        /// Constructor to construct a Color with the specified components with the
+        /// blue and alpha component set to 1.0f.
+        /// </summary>
+        /// <param name="_red">Red component to set.</param>
+        /// <param name="_green">Green component to set.</param>
+        Color(float _red, float _green);
+        /// <summary>
+        /// Constructor to construct a Color with the specified components with the
+        /// alpha component set to 1.0f.
+        /// </summary>
+        /// <param name="_red">Red component to set.</param>
+        /// <param name="_green">Green component to set.</param>
+        /// <param name="_blue">Blue component to set.</param>
+        Color(float _red, float _green, float _blue);
+        /// <summary>
+        /// Constructor to construct a Color with the specified components.
+        /// </summary>
+        /// <param name="_red">Red component to set.</param>
+        /// <param name="_green">Green component to set.</param>
+        /// <param name="_blue">Blue component to set.</param>
+        /// <param name="_alpha">Alpha component to set.</param>
+        Color(float _red, float _green, float _blue, float _alpha);
+
+        /*-----------------------------------------------------------------------------*/
+        /* Public Members                                                              */
+        /*-----------------------------------------------------------------------------*/
+        /// <summary>
+        /// Red component of the colour. Ranges from 0.0f to 1.0f.
+        /// </summary>
+        float r;
+        /// <summary>
+        /// Green component of the colour. Ranges from 0.0f to 1.0f.
+        /// </summary>
+        float g;
+        /// <summary>
+        /// Blue component of the colour. Ranges from 0.0f to 1.0f.
+        /// </summary>
+        float b;
+        /// <summary>
+        /// Alpha component of the colour. Ranges from 0.0f to 1.0f.
+        /// </summary>
+        float a;
+
+        /*-----------------------------------------------------------------------------*/
+        /* IEquatable                                                                  */
+        /*-----------------------------------------------------------------------------*/
+        /// <summary>
+        /// Compares equality with an object of the same type.
+        /// </summary>
+        /// <param name="other">The object to compare with.</param>
+        /// <returns>True if both objects are the same.</returns>
+        virtual bool Equals(Color other);
+
+        /*-----------------------------------------------------------------------------*/
+        /* Object                                                                      */
+        /*-----------------------------------------------------------------------------*/
+        /// <summary>
+        /// Compares equality with another unboxed object.
+        /// </summary>
+        /// <param name="o">The unboxed object to compare with.</param>
+        /// <returns>True if both objects are the same.</returns>
+        bool Equals(Object^ o) override; 
+        /// <summary>
+        /// Gets a unique hash for this object.
+        /// </summary>
+        /// <returns>Unique hash for this object.</returns>
+        int  GetHashCode() override;        
+
+
+        /*-----------------------------------------------------------------------------*/
+        /* Static Functions                                                            */
+        /*-----------------------------------------------------------------------------*/
+        /// <summary>
+        /// Linearly interpolates between two specified points.
+        /// This is most commonly used to find a point some fraction of the way along a 
+        /// line between two endpoints.
+        /// </summary>
+        /// <param name="colA">The start Color, returned when t = 0.0.</param>
+        /// <param name="colB">The end Color, returned when t = 1.0.</param>
+        /// <param name="t">
+        /// Value used to interpolate between a and b which is clamped to
+        /// the range[0, 1].
+        /// </param>
+        /// <returns>The interpolated Vector3.</returns>
+        static Color Lerp(Color colA, Color colB, float t);
+        /// <summary>
+        /// Linearly interpolates between two specified points. 
+        /// This is most commonly used to find a point some fraction of the way along a 
+        /// line between two endpoints.
+        /// Unlike Lerp(), t is not clamped to a range at all.
+        /// </summary>
+        /// <param name="colA">The start Color, returned when t = 0.0.</param>
+        /// <param name="colB">The end Color, returned when t = 1.0.</param>
+        /// <param name="t">Value used to interpolate between a and b.</param>
+        /// <returns>The interpolated Color.</returns>
+        static Color LerpUnclamped(Color colA, Color colB, float t);
+
+        /*-----------------------------------------------------------------------------*/
+        /* Overloaded Operators                                                        */
+        /*-----------------------------------------------------------------------------*/
+        /// <summary>
+        /// Adds two Colors together and returns the result.
+        /// </summary>
+        /// <param name="lhs">Color to add.</param>
+        /// <param name="rhs">Another Color to add.</param>
+        /// <returns>The result of lhs added to rhs</returns>
+        static Color operator+(Color lhs, Color rhs);
+        /// <summary>
+        /// Subtracts a Color from another Color and returns the result.
+        /// </summary>
+        /// <param name="lhs">Color to subtract from.</param>
+        /// <param name="rhs">Another Color to subtract.</param>
+        /// <returns>The result of rhs subtracted from lhs.</returns>
+        static Color operator-(Color lhs, Color rhs);
+        /// <summary>
+        /// Calculates the component-wise multiplication of two Colors and returns the
+        /// result.
+        /// </summary>
+        /// <param name="lhs">Color to multiply with.</param>
+        /// <param name="rhs">Another Color to multiply with.</param>
+        /// <returns>The result of rhs subtracted from lhs.</returns>
+        static Color operator*(Color lhs, Color rhs);
+        /// <summary>
+        /// Calculates the multiplication of a Color with a scalar value and returns 
+        /// the result.
+        /// </summary>
+        /// <param name="lhs">Color to multiply with.</param>
+        /// <param name="rhs">Scalar to multiply with.</param>
+        /// <returns>The result of the scalar multiplication.</returns>
+        static Color operator*(Color lhs, float rhs);
+        /// <summary>
+        /// Calculates the division of a Color with a scalar value and returns 
+        /// the result.
+        /// </summary>
+        /// <param name="lhs">Scalar to divide with.</param>
+        /// <param name="rhs">Color to divide with.</param>
+        /// <returns>The result of the scalar division.</returns>
+        static Color operator/(Color lhs, float rhs);
+        /// <summary>
+        /// Checks if two Colors are approximately equal.
+        /// </summary>
+        /// <param name="lhs">Color to compare.</param>
+        /// <param name="rhs">Another Color to compare.</param>
+        /// <returns>
+        /// True if all components are approximately equal within the default 
+        /// tolerance value.
+        /// </returns>
+        static bool operator==(Color lhs, Color rhs);
+        /// <summary>
+        /// Checks if two Colors are not approximately equal.
+        /// </summary>
+        /// <param name="lhs">Color to compare.</param>
+        /// <param name="rhs">Another Color to compare.</param>
+        /// <returns>
+        /// True if all components are not approximately equal within the default 
+        /// tolerance value.
+        /// </returns>
+        static bool operator!=(Color lhs, Color rhs);
+    };
+} 
diff --git a/SHADE_Managed/src/Math/Math.cxx b/SHADE_Managed/src/Math/Math.cxx
index fa72e2b6..bc625f5b 100644
--- a/SHADE_Managed/src/Math/Math.cxx
+++ b/SHADE_Managed/src/Math/Math.cxx
@@ -54,4 +54,15 @@ namespace SHADE
     {
         return (value - a) / (b - a);
     }
+
+    bool Math::CompareFloat(float a, float b)
+    {
+        return CompareFloat(a, b, Epsilon);
+    }
+
+    bool Math::CompareFloat(float a, float b, float tolerance)
+    {
+        return System::MathF::Abs(a - b) < tolerance;
+    }
+
 }
diff --git a/SHADE_Managed/src/Math/Math.hxx b/SHADE_Managed/src/Math/Math.hxx
index 1578d97c..c6b8394e 100644
--- a/SHADE_Managed/src/Math/Math.hxx
+++ b/SHADE_Managed/src/Math/Math.hxx
@@ -81,12 +81,30 @@ namespace SHADE
         /// <returns>The interpolated float result between the two float values.</returns>
         static float LerpUnclamped(float a, float b, float t);
         /// <summary>
-        /// Calculates the linear parameter t that produces the interpolant value within the range [a, b].
+        /// Calculates the linear parameter t that produces the interpolant value within
+        /// the range [a, b].
         /// </summary>
         /// <param name="a">Start value.</param>
         /// <param name="b">End value.</param>
         /// <param name="value">Value between start and end.</param>
         /// <returns>Percentage of value between start and end.</returns>
         static float InverseLerp(float a, float b, float value);
+        /// <summary>
+        /// Compares if two float values are close enough to be the same with a tolerance
+        /// of Epsilon.
+        /// </summary>
+        /// <param name="a">One of the values to compare.</param>
+        /// <param name="b">The other value to compare.</param>
+        /// <returns>True if a and b are practically the same.</returns>
+        static bool CompareFloat(float a, float b);
+        /// <summary>
+        /// Compares if two float values are close enough to be the same with the
+        /// specified tolerance value.
+        /// </summary>
+        /// <param name="a">One of the values to compare.</param>
+        /// <param name="b">The other value to compare.</param>
+        /// <param name="tolerance">Tolerance for floating point comparison.</param>
+        /// <returns>True if a and b are practically the same.</returns>
+        static bool CompareFloat(float a, float b, float tolerance);
     };
 }