diff --git a/CMakeLists.txt b/CMakeLists.txt
index e84d3324..e084e7e0 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -63,7 +63,7 @@ set(HEADER_FILES include/emulator.hpp include/helpers.hpp include/opengl.hpp inc
                  include/kernel/handles.hpp include/services/hid.hpp include/services/fs.hpp
                  include/services/gsp_gpu.hpp include/services/gsp_lcd.hpp include/arm_defs.hpp
                  include/PICA/gpu.hpp include/PICA/regs.hpp include/services/ndm.hpp
-                 include/PICA/shader.hpp include/PICA/shader_unit.hpp
+                 include/PICA/shader.hpp include/PICA/shader_unit.hpp include/PICA/float_types.hpp
 )
 
 set(THIRD_PARTY_SOURCE_FILES third_party/imgui/imgui.cpp
diff --git a/include/PICA/float_types.hpp b/include/PICA/float_types.hpp
new file mode 100644
index 00000000..f07e9e46
--- /dev/null
+++ b/include/PICA/float_types.hpp
@@ -0,0 +1,149 @@
+// Copyright 2015 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+// Slightly adapted for the purposes of this project
+#pragma once
+
+#include <cmath>
+#include <cstring>
+#include "helpers.hpp"
+
+namespace Floats {
+    /**
+     * Template class for converting arbitrary Pica float types to IEEE 754 32-bit single-precision
+     * floating point.
+     *
+     * When decoding, format is as follows:
+     *  - The first `M` bits are the mantissa
+     *  - The next `E` bits are the exponent
+     *  - The last bit is the sign bit
+     *
+     * @todo Verify on HW if this conversion is sufficiently accurate.
+     */
+    template <unsigned M, unsigned E>
+    struct Float {
+    public:
+        static Float<M, E> FromFloat32(float val) {
+            Float<M, E> ret;
+            ret.value = val;
+            return ret;
+        }
+
+        static Float<M, E> FromRaw(u32 hex) {
+            Float<M, E> res;
+
+            const int width = M + E + 1;
+            const int bias = 128 - (1 << (E - 1));
+            int exponent = (hex >> M) & ((1 << E) - 1);
+            const unsigned mantissa = hex & ((1 << M) - 1);
+            const unsigned sign = (hex >> (E + M)) << 31;
+
+            if (hex & ((1 << (width - 1)) - 1)) {
+                if (exponent == (1 << E) - 1)
+                    exponent = 255;
+                else
+                    exponent += bias;
+                hex = sign | (mantissa << (23 - M)) | (exponent << 23);
+            }
+            else {
+                hex = sign;
+            }
+
+            std::memcpy(&res.value, &hex, sizeof(float));
+
+            return res;
+        }
+
+        static Float<M, E> Zero() {
+            return FromFloat32(0.f);
+        }
+
+        // Not recommended for anything but logging
+        float ToFloat32() const {
+            return value;
+        }
+
+        Float<M, E> operator*(const Float<M, E>& flt) const {
+            float result = value * flt.ToFloat32();
+            // PICA gives 0 instead of NaN when multiplying by inf
+            if (std::isnan(result))
+                if (!std::isnan(value) && !std::isnan(flt.ToFloat32()))
+                    result = 0.f;
+            return Float<M, E>::FromFloat32(result);
+        }
+
+        Float<M, E> operator/(const Float<M, E>& flt) const {
+            return Float<M, E>::FromFloat32(ToFloat32() / flt.ToFloat32());
+        }
+
+        Float<M, E> operator+(const Float<M, E>& flt) const {
+            return Float<M, E>::FromFloat32(ToFloat32() + flt.ToFloat32());
+        }
+
+        Float<M, E> operator-(const Float<M, E>& flt) const {
+            return Float<M, E>::FromFloat32(ToFloat32() - flt.ToFloat32());
+        }
+
+        Float<M, E>& operator*=(const Float<M, E>& flt) {
+            value = operator*(flt).value;
+            return *this;
+        }
+
+        Float<M, E>& operator/=(const Float<M, E>& flt) {
+            value /= flt.ToFloat32();
+            return *this;
+        }
+
+        Float<M, E>& operator+=(const Float<M, E>& flt) {
+            value += flt.ToFloat32();
+            return *this;
+        }
+
+        Float<M, E>& operator-=(const Float<M, E>& flt) {
+            value -= flt.ToFloat32();
+            return *this;
+        }
+
+        Float<M, E> operator-() const {
+            return Float<M, E>::FromFloat32(-ToFloat32());
+        }
+
+        bool operator<(const Float<M, E>& flt) const {
+            return ToFloat32() < flt.ToFloat32();
+        }
+
+        bool operator>(const Float<M, E>& flt) const {
+            return ToFloat32() > flt.ToFloat32();
+        }
+
+        bool operator>=(const Float<M, E>& flt) const {
+            return ToFloat32() >= flt.ToFloat32();
+        }
+
+        bool operator<=(const Float<M, E>& flt) const {
+            return ToFloat32() <= flt.ToFloat32();
+        }
+
+        bool operator==(const Float<M, E>& flt) const {
+            return ToFloat32() == flt.ToFloat32();
+        }
+
+        bool operator!=(const Float<M, E>& flt) const {
+            return ToFloat32() != flt.ToFloat32();
+        }
+
+    private:
+        static constexpr unsigned MASK = (1 << (M + E + 1)) - 1;
+        static constexpr unsigned MANTISSA_MASK = (1 << M) - 1;
+        static constexpr unsigned EXPONENT_MASK = (1 << E) - 1;
+
+        // Stored as a regular float, merely for convenience
+        // TODO: Perform proper arithmetic on this!
+        float value;
+    };
+
+    using float24 = Float<16, 7>;
+    using float20 = Float<12, 7>;
+    using float16 = Float<10, 5>;
+
+} // namespace Pica
diff --git a/tests/SimplerTri/source/main.c b/tests/SimplerTri/source/main.c
index f99e519f..63a19af0 100644
--- a/tests/SimplerTri/source/main.c
+++ b/tests/SimplerTri/source/main.c
@@ -46,7 +46,7 @@ static void sceneInit(void)
 	AttrInfo_AddFixed(attrInfo, 1); // v1=color
 
 	// Set the fixed attribute (color) to solid white
-	C3D_FixedAttribSet(1, 1.0, 1.0, 1.0, 1.0);
+	C3D_FixedAttribSet(1, 1.0, 0.5, 0.2, 1.0);
 
 	// Compute the projection matrix
 	Mtx_OrthoTilt(&projection, 0.0, 400.0, 0.0, 240.0, 0.0, 1.0, true);