diff --git a/include/ui/ColorSpace.h b/include/ui/ColorSpace.h
new file mode 100644
index 0000000..2543e7f
--- /dev/null
+++ b/include/ui/ColorSpace.h
@@ -0,0 +1,192 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ANDROID_UI_COLOR_SPACE
+#define ANDROID_UI_COLOR_SPACE
+
+#include <array>
+#include <cmath>
+#include <functional>
+#include <string>
+
+#include <ui/mat3.h>
+#include <ui/scalar.h>
+#include <ui/vec2.h>
+#include <ui/vec3.h>
+
+namespace android {
+
+class ColorSpace {
+public:
+    typedef std::function<float(float)> transfer_function;
+    typedef std::function<float(float)> clamping_function;
+
+    /**
+     * Creates a named color space with the specified RGB->XYZ
+     * conversion matrix. The white point and primaries will be
+     * computed from the supplied matrix.
+     *
+     * The default transfer functions are a linear response x->x
+     * and the default clamping function is a simple saturate
+     * (clamp(x, 0, 1)).
+     */
+    ColorSpace(
+            const std::string& name,
+            const mat3& rgbToXYZ,
+            transfer_function OETF = linearReponse,
+            transfer_function EOTF = linearReponse,
+            clamping_function clamper = saturate<float>
+    ) noexcept;
+
+    /**
+     * Creates a named color space with the specified primaries
+     * and white point. The RGB<>XYZ conversion matrices are
+     * computed from the primaries and white point.
+     *
+     * The default transfer functions are a linear response x->x
+     * and the default clamping function is a simple saturate
+     * (clamp(x, 0, 1)).
+     */
+    ColorSpace(
+            const std::string& name,
+            const std::array<float2, 3>& primaries,
+            const float2& whitePoint,
+            transfer_function OETF = linearReponse,
+            transfer_function EOTF = linearReponse,
+            clamping_function clamper = saturate<float>
+    ) noexcept;
+
+    ColorSpace() noexcept = delete;
+
+    /**
+     * Encodes the supplied RGB value using this color space's
+     * opto-electronic transfer function.
+     */
+    constexpr float3 fromLinear(const float3& v) const noexcept {
+        return apply(v, mOETF);
+    }
+
+    /**
+     * Decodes the supplied RGB value using this color space's
+     * electro-optical transfer function.
+     */
+    constexpr float3 toLinear(const float3& v) const noexcept {
+        return apply(v, mEOTF);
+    }
+
+    /**
+     * Converts the supplied XYZ value to RGB. The returned value
+     * is encoded with this color space's opto-electronic transfer
+     * function and clamped by this color space's clamping function.
+     */
+    constexpr float3 xyzToRGB(const float3& xyz) const noexcept {
+        return apply(fromLinear(mXYZtoRGB * xyz), mClamper);
+    }
+
+    /**
+     * Converts the supplied RGB value to XYZ. The input RGB value
+     * is decoded using this color space's electro-optical function
+     * before being converted to XYZ. The returned result is clamped
+     * by this color space's clamping function.
+     */
+    constexpr float3 rgbToXYZ(const float3& rgb) const noexcept {
+        return apply(mRGBtoXYZ * toLinear(rgb), mClamper);
+    }
+
+    constexpr const std::string& getName() const noexcept {
+        return mName;
+    }
+
+    constexpr const mat3& getRGBtoXYZ() const noexcept {
+        return mRGBtoXYZ;
+    }
+
+    constexpr const mat3& getXYZtoRGB() const noexcept {
+        return mXYZtoRGB;
+    }
+
+    constexpr const transfer_function& getOETF() const noexcept {
+        return mOETF;
+    }
+
+    constexpr const transfer_function& getEOTF() const noexcept {
+        return mEOTF;
+    }
+
+    constexpr const clamping_function& getClamper() const noexcept {
+        return mClamper;
+    }
+
+    constexpr const std::array<float2, 3>& getPrimaries() const noexcept {
+        return mPrimaries;
+    }
+
+    constexpr const float2& getWhitePoint() const noexcept {
+        return mWhitePoint;
+    }
+
+    /**
+     * Converts the supplied XYZ value to xyY.
+     */
+    static constexpr float2 xyY(const float3& XYZ) {
+        return XYZ.xy / dot(XYZ, float3{1});
+    }
+
+    /**
+     * Converts the supplied xyY value to XYZ.
+     */
+    static constexpr float3 XYZ(const float3& xyY) {
+        return float3{(xyY.x * xyY.z) / xyY.y, xyY.z, ((1 - xyY.x - xyY.y) * xyY.z) / xyY.y};
+    }
+
+    static const ColorSpace sRGB();
+    static const ColorSpace linearSRGB();
+    static const ColorSpace extendedSRGB();
+    static const ColorSpace linearExtendedSRGB();
+    static const ColorSpace NTSC();
+    static const ColorSpace BT709();
+    static const ColorSpace BT2020();
+    static const ColorSpace AdobeRGB();
+    static const ColorSpace ProPhotoRGB();
+    static const ColorSpace DisplayP3();
+    static const ColorSpace DCIP3();
+    static const ColorSpace ACES();
+    static const ColorSpace ACEScg();
+
+private:
+    static constexpr mat3 computeXYZMatrix(
+            const std::array<float2, 3>& primaries, const float2& whitePoint);
+
+    static constexpr float linearReponse(float v) {
+        return v;
+    }
+
+    const std::string mName;
+
+    const mat3 mRGBtoXYZ;
+    const mat3 mXYZtoRGB;
+
+    const transfer_function mOETF;
+    const transfer_function mEOTF;
+    const clamping_function mClamper;
+
+    std::array<float2, 3> mPrimaries;
+    float2 mWhitePoint;
+};
+
+}; // namespace android
+
+#endif // ANDROID_UI_COLOR_SPACE
diff --git a/include/ui/TMatHelpers.h b/include/ui/TMatHelpers.h
index 9daca08..8edf5f8 100644
--- a/include/ui/TMatHelpers.h
+++ b/include/ui/TMatHelpers.h
@@ -41,6 +41,12 @@
 
 #define PURE __attribute__((pure))
 
+#if __cplusplus >= 201402L
+#define CONSTEXPR constexpr
+#else
+#define CONSTEXPR
+#endif
+
 namespace android {
 namespace details {
 // -------------------------------------------------------------------------------------
@@ -103,10 +109,10 @@
         // Factor out the lower triangle
         for (size_t j = 0; j < N; ++j) {
             if (j != i) {
-                const T t = tmp[j][i];
+                const T d = tmp[j][i];
                 for (size_t k = 0; k < N; ++k) {
-                    tmp[j][k] -= tmp[i][k] * t;
-                    inverted[j][k] -= inverted[i][k] * t;
+                    tmp[j][k] -= tmp[i][k] * d;
+                    inverted[j][k] -= inverted[i][k] * d;
                 }
             }
         }
@@ -119,7 +125,7 @@
 //------------------------------------------------------------------------------
 // 2x2 matrix inverse is easy.
 template <typename MATRIX>
-MATRIX PURE fastInverse2(const MATRIX& x) {
+CONSTEXPR MATRIX PURE fastInverse2(const MATRIX& x) {
     typedef typename MATRIX::value_type T;
 
     // Assuming the input matrix is:
@@ -153,7 +159,7 @@
 // matrix inversion:
 // http://en.wikipedia.org/wiki/Invertible_matrix#Inversion_of_3.C3.973_matrices
 template <typename MATRIX>
-MATRIX PURE fastInverse3(const MATRIX& x) {
+CONSTEXPR MATRIX PURE fastInverse3(const MATRIX& x) {
     typedef typename MATRIX::value_type T;
 
     // Assuming the input matrix is:
@@ -216,7 +222,6 @@
     return inverted;
 }
 
-
 /**
  * Inversion function which switches on the matrix size.
  * @warning This function assumes the matrix is invertible. The result is
@@ -232,7 +237,7 @@
 }
 
 template<typename MATRIX_R, typename MATRIX_A, typename MATRIX_B>
-MATRIX_R PURE multiply(const MATRIX_A& lhs, const MATRIX_B& rhs) {
+CONSTEXPR MATRIX_R PURE multiply(const MATRIX_A& lhs, const MATRIX_B& rhs) {
     // pre-requisite:
     //  lhs : D columns, R rows
     //  rhs : C columns, D rows
@@ -254,7 +259,7 @@
 
 // transpose. this handles matrices of matrices
 template <typename MATRIX>
-MATRIX PURE transpose(const MATRIX& m) {
+CONSTEXPR MATRIX PURE transpose(const MATRIX& m) {
     // for now we only handle square matrix transpose
     static_assert(MATRIX::NUM_COLS == MATRIX::NUM_ROWS, "transpose only supports square matrices");
     MATRIX result(MATRIX::NO_INIT);
@@ -268,7 +273,7 @@
 
 // trace. this handles matrices of matrices
 template <typename MATRIX>
-typename MATRIX::value_type PURE trace(const MATRIX& m) {
+CONSTEXPR typename MATRIX::value_type PURE trace(const MATRIX& m) {
     static_assert(MATRIX::NUM_COLS == MATRIX::NUM_ROWS, "trace only defined for square matrices");
     typename MATRIX::value_type result(0);
     for (size_t col = 0; col < MATRIX::NUM_COLS; ++col) {
@@ -279,7 +284,7 @@
 
 // diag. this handles matrices of matrices
 template <typename MATRIX>
-typename MATRIX::col_type PURE diag(const MATRIX& m) {
+CONSTEXPR typename MATRIX::col_type PURE diag(const MATRIX& m) {
     static_assert(MATRIX::NUM_COLS == MATRIX::NUM_ROWS, "diag only defined for square matrices");
     typename MATRIX::col_type result(MATRIX::col_type::NO_INIT);
     for (size_t col = 0; col < MATRIX::NUM_COLS; ++col) {
@@ -389,7 +394,7 @@
 
     // matrix * matrix, result is a matrix of the same type than the lhs matrix
     template<typename U>
-    friend BASE<T> PURE operator *(const BASE<T>& lhs, const BASE<U>& rhs) {
+    friend CONSTEXPR BASE<T> PURE operator *(const BASE<T>& lhs, const BASE<U>& rhs) {
         return matrix::multiply<BASE<T> >(lhs, rhs);
     }
 };
@@ -419,7 +424,7 @@
      * is instantiated, at which point they're only templated on the 2nd parameter
      * (the first one, BASE<T> being known).
      */
-    friend inline BASE<T> PURE inverse(const BASE<T>& matrix) {
+    friend inline CONSTEXPR BASE<T> PURE inverse(const BASE<T>& matrix) {
         return matrix::inverse(matrix);
     }
     friend inline constexpr BASE<T> PURE transpose(const BASE<T>& m) {
@@ -454,7 +459,7 @@
     }
 
     template <typename VEC>
-    static BASE<T> translate(const VEC& t) {
+    static CONSTEXPR BASE<T> translate(const VEC& t) {
         BASE<T> r;
         r[BASE<T>::NUM_COLS-1] = t;
         return r;
@@ -465,7 +470,7 @@
         return BASE<T>(s);
     }
 
-    friend inline BASE<T> PURE abs(BASE<T> m) {
+    friend inline CONSTEXPR BASE<T> PURE abs(BASE<T> m) {
         for (size_t col = 0; col < BASE<T>::NUM_COLS; ++col) {
             m[col] = abs(m[col]);
         }
@@ -482,7 +487,7 @@
     }
 
     template <typename A, typename VEC>
-    static BASE<T> rotate(A radian, const VEC& about) {
+    static CONSTEXPR BASE<T> rotate(A radian, const VEC& about) {
         BASE<T> r;
         T c = std::cos(radian);
         T s = std::sin(radian);
@@ -533,7 +538,7 @@
         typename = typename std::enable_if<std::is_arithmetic<P>::value >::type,
         typename = typename std::enable_if<std::is_arithmetic<R>::value >::type
     >
-    static BASE<T> eulerYXZ(Y yaw, P pitch, R roll) {
+    static CONSTEXPR BASE<T> eulerYXZ(Y yaw, P pitch, R roll) {
         return eulerZYX(roll, pitch, yaw);
     }
 
@@ -552,7 +557,7 @@
     typename = typename std::enable_if<std::is_arithmetic<P>::value >::type,
     typename = typename std::enable_if<std::is_arithmetic<R>::value >::type
     >
-    static BASE<T> eulerZYX(Y yaw, P pitch, R roll) {
+    static CONSTEXPR BASE<T> eulerZYX(Y yaw, P pitch, R roll) {
         BASE<T> r;
         T cy = std::cos(yaw);
         T sy = std::sin(yaw);
@@ -630,5 +635,6 @@
 #undef LIKELY
 #undef UNLIKELY
 #undef PURE
+#undef CONSTEXPR
 
 #endif  // UI_TMATHELPERS_H_
diff --git a/include/ui/TVecHelpers.h b/include/ui/TVecHelpers.h
index 1eaa6e6..de1d9ff 100644
--- a/include/ui/TVecHelpers.h
+++ b/include/ui/TVecHelpers.h
@@ -28,6 +28,12 @@
 
 #define PURE __attribute__((pure))
 
+#if __cplusplus >= 201402L
+#define CONSTEXPR constexpr
+#else
+#define CONSTEXPR
+#endif
+
 namespace android {
 namespace details {
 // -------------------------------------------------------------------------------------
@@ -228,6 +234,7 @@
         }
         return rhs;
     }
+
     VECTOR<T>& operator --() {
         VECTOR<T>& rhs = static_cast<VECTOR<T>&>(*this);
         for (size_t i = 0; i < rhs.size(); i++) {
@@ -235,7 +242,8 @@
         }
         return rhs;
     }
-    VECTOR<T> operator -() const {
+
+    CONSTEXPR VECTOR<T> operator -() const {
         VECTOR<T> r(VECTOR<T>::NO_INIT);
         VECTOR<T> const& rv(static_cast<VECTOR<T> const&>(*this));
         for (size_t i = 0; i < r.size(); i++) {
@@ -333,7 +341,7 @@
      * (the first one, BASE<T> being known).
      */
     template<typename RT>
-    friend inline T PURE dot(const VECTOR<T>& lv, const VECTOR<RT>& rv) {
+    friend inline CONSTEXPR T PURE dot(const VECTOR<T>& lv, const VECTOR<RT>& rv) {
         T r(0);
         for (size_t i = 0; i < lv.size(); i++) {
             //r = std::fma(lv[i], rv[i], r);
@@ -372,71 +380,71 @@
         return lv * (T(1) / length(lv));
     }
 
-    friend inline VECTOR<T> PURE rcp(VECTOR<T> v) {
+    friend inline constexpr VECTOR<T> PURE rcp(VECTOR<T> v) {
         return T(1) / v;
     }
 
-    friend inline VECTOR<T> PURE abs(VECTOR<T> v) {
+    friend inline CONSTEXPR VECTOR<T> PURE abs(VECTOR<T> v) {
         for (size_t i=0 ; i<v.size() ; i++) {
             v[i] = std::abs(v[i]);
         }
         return v;
     }
 
-    friend inline VECTOR<T> PURE floor(VECTOR<T> v) {
+    friend inline CONSTEXPR VECTOR<T> PURE floor(VECTOR<T> v) {
         for (size_t i=0 ; i<v.size() ; i++) {
             v[i] = std::floor(v[i]);
         }
         return v;
     }
 
-    friend inline VECTOR<T> PURE ceil(VECTOR<T> v) {
+    friend inline CONSTEXPR VECTOR<T> PURE ceil(VECTOR<T> v) {
         for (size_t i=0 ; i<v.size() ; i++) {
             v[i] = std::ceil(v[i]);
         }
         return v;
     }
 
-    friend inline VECTOR<T> PURE round(VECTOR<T> v) {
+    friend inline CONSTEXPR VECTOR<T> PURE round(VECTOR<T> v) {
         for (size_t i=0 ; i<v.size() ; i++) {
             v[i] = std::round(v[i]);
         }
         return v;
     }
 
-    friend inline VECTOR<T> PURE inversesqrt(VECTOR<T> v) {
+    friend inline CONSTEXPR VECTOR<T> PURE inversesqrt(VECTOR<T> v) {
         for (size_t i=0 ; i<v.size() ; i++) {
             v[i] = T(1) / std::sqrt(v[i]);
         }
         return v;
     }
 
-    friend inline VECTOR<T> PURE sqrt(VECTOR<T> v) {
+    friend inline CONSTEXPR VECTOR<T> PURE sqrt(VECTOR<T> v) {
         for (size_t i=0 ; i<v.size() ; i++) {
             v[i] = std::sqrt(v[i]);
         }
         return v;
     }
 
-    friend inline VECTOR<T> PURE pow(VECTOR<T> v, T p) {
+    friend inline CONSTEXPR VECTOR<T> PURE pow(VECTOR<T> v, T p) {
         for (size_t i=0 ; i<v.size() ; i++) {
             v[i] = std::pow(v[i], p);
         }
         return v;
     }
 
-    friend inline VECTOR<T> PURE saturate(const VECTOR<T>& lv) {
+    friend inline CONSTEXPR VECTOR<T> PURE saturate(const VECTOR<T>& lv) {
         return clamp(lv, T(0), T(1));
     }
 
-    friend inline VECTOR<T> PURE clamp(VECTOR<T> v, T min, T max) {
+    friend inline CONSTEXPR VECTOR<T> PURE clamp(VECTOR<T> v, T min, T max) {
         for (size_t i=0 ; i< v.size() ; i++) {
             v[i] = std::min(max, std::max(min, v[i]));
         }
         return v;
     }
 
-    friend inline VECTOR<T> PURE fma(const VECTOR<T>& lv, const VECTOR<T>& rv, VECTOR<T> a) {
+    friend inline CONSTEXPR VECTOR<T> PURE fma(const VECTOR<T>& lv, const VECTOR<T>& rv, VECTOR<T> a) {
         for (size_t i=0 ; i<lv.size() ; i++) {
             //a[i] = std::fma(lv[i], rv[i], a[i]);
             a[i] += (lv[i] * rv[i]);
@@ -444,21 +452,21 @@
         return a;
     }
 
-    friend inline VECTOR<T> PURE min(const VECTOR<T>& u, VECTOR<T> v) {
+    friend inline CONSTEXPR VECTOR<T> PURE min(const VECTOR<T>& u, VECTOR<T> v) {
         for (size_t i=0 ; i<v.size() ; i++) {
             v[i] = std::min(u[i], v[i]);
         }
         return v;
     }
 
-    friend inline VECTOR<T> PURE max(const VECTOR<T>& u, VECTOR<T> v) {
+    friend inline CONSTEXPR VECTOR<T> PURE max(const VECTOR<T>& u, VECTOR<T> v) {
         for (size_t i=0 ; i<v.size() ; i++) {
             v[i] = std::max(u[i], v[i]);
         }
         return v;
     }
 
-    friend inline T PURE max(const VECTOR<T>& v) {
+    friend inline CONSTEXPR T PURE max(const VECTOR<T>& v) {
         T r(std::numeric_limits<T>::lowest());
         for (size_t i=0 ; i<v.size() ; i++) {
             r = std::max(r, v[i]);
@@ -466,13 +474,20 @@
         return r;
     }
 
-    friend inline T PURE min(const VECTOR<T>& v) {
+    friend inline CONSTEXPR T PURE min(const VECTOR<T>& v) {
         T r(std::numeric_limits<T>::max());
         for (size_t i=0 ; i<v.size() ; i++) {
             r = std::min(r, v[i]);
         }
         return r;
     }
+
+    friend inline CONSTEXPR VECTOR<T> PURE apply(VECTOR<T> v, const std::function<T(T)>& f) {
+        for (size_t i=0 ; i<v.size() ; i++) {
+            v[i] = f(v[i]);
+        }
+        return v;
+    }
 };
 
 /*
@@ -502,6 +517,7 @@
     }
 };
 
+#undef CONSTEXPR
 #undef PURE
 
 // -------------------------------------------------------------------------------------
diff --git a/include/ui/half.h b/include/ui/half.h
index cbc1ef0..7a271dc 100644
--- a/include/ui/half.h
+++ b/include/ui/half.h
@@ -30,6 +30,12 @@
 #   define UNLIKELY( exp )  (__builtin_expect( !!(exp), 0 ))
 #endif
 
+#if __cplusplus >= 201402L
+#define CONSTEXPR constexpr
+#else
+#define CONSTEXPR
+#endif
+
 namespace android {
 
 /*
@@ -50,13 +56,13 @@
     struct fp16 {
         uint16_t bits = 0;
         fp16() noexcept = default;
-        explicit constexpr fp16(uint16_t bits) noexcept : bits(bits) { }
+        explicit constexpr fp16(uint16_t b) noexcept : bits(b) { }
         void setS(unsigned int s) noexcept { bits = uint16_t((bits & 0x7FFF) | (s<<15)); }
         void setE(unsigned int s) noexcept { bits = uint16_t((bits & 0xE3FF) | (s<<10)); }
         void setM(unsigned int s) noexcept { bits = uint16_t((bits & 0xFC00) | (s<< 0)); }
-        unsigned int getS() const noexcept { return  bits >> 15u; }
-        unsigned int getE() const noexcept { return (bits >> 10u) & 0x1Fu; }
-        unsigned int getM() const noexcept { return  bits         & 0x3FFu; }
+        constexpr unsigned int getS() const noexcept { return  bits >> 15u; }
+        constexpr unsigned int getE() const noexcept { return (bits >> 10u) & 0x1Fu; }
+        constexpr unsigned int getM() const noexcept { return  bits         & 0x3FFu; }
     };
     struct fp32 {
         union {
@@ -68,14 +74,14 @@
         void setS(unsigned int s) noexcept { bits = uint32_t((bits & 0x7FFFFFFF) | (s<<31)); }
         void setE(unsigned int s) noexcept { bits = uint32_t((bits & 0x807FFFFF) | (s<<23)); }
         void setM(unsigned int s) noexcept { bits = uint32_t((bits & 0xFF800000) | (s<< 0)); }
-        unsigned int getS() const noexcept { return  bits >> 31u; }
-        unsigned int getE() const noexcept { return (bits >> 23u) & 0xFFu; }
-        unsigned int getM() const noexcept { return  bits         & 0x7FFFFFu; }
+        constexpr unsigned int getS() const noexcept { return  bits >> 31u; }
+        constexpr unsigned int getE() const noexcept { return (bits >> 23u) & 0xFFu; }
+        constexpr unsigned int getM() const noexcept { return  bits         & 0x7FFFFFu; }
     };
 
 public:
-    half(float v) noexcept : mBits(ftoh(v)) { }
-    operator float() const noexcept { return htof(mBits); }
+    CONSTEXPR half(float v) noexcept : mBits(ftoh(v)) { }
+    CONSTEXPR operator float() const noexcept { return htof(mBits); }
 
     uint16_t getBits() const noexcept { return mBits.bits; }
     unsigned int getExponent() const noexcept { return mBits.getE(); }
@@ -83,23 +89,23 @@
 
 private:
     friend class std::numeric_limits<half>;
-    friend half operator"" _hf(long double v);
+    friend CONSTEXPR half operator"" _hf(long double v);
 
     enum Binary { binary };
     explicit constexpr half(Binary, uint16_t bits) noexcept : mBits(bits) { }
-    static fp16 ftoh(float v) noexcept;
-    static float htof(fp16 v) noexcept;
+    static CONSTEXPR fp16 ftoh(float v) noexcept;
+    static CONSTEXPR float htof(fp16 v) noexcept;
     fp16 mBits;
 };
 
-inline /* constexpr */ half::fp16 half::ftoh(float v) noexcept {
+inline CONSTEXPR half::fp16 half::ftoh(float v) noexcept {
     fp16 out;
     fp32 in(v);
     if (UNLIKELY(in.getE() == 0xFF)) { // inf or nan
         out.setE(0x1F);
         out.setM(in.getM() ? 0x200 : 0);
     } else {
-        int e = in.getE() - 127 + 15;
+        int e = static_cast<int>(in.getE()) - 127 + 15;
         if (e >= 0x1F) {
             // overflow
             out.setE(0x31); // +/- inf
@@ -120,7 +126,7 @@
     return out;
 }
 
-inline float half::htof(half::fp16 in) noexcept {
+inline CONSTEXPR float half::htof(half::fp16 in) noexcept {
     fp32 out;
     if (UNLIKELY(in.getE() == 0x1F)) { // inf or nan
         out.setE(0xFF);
@@ -132,7 +138,7 @@
                 // (it's stupid because they can be represented as regular float)
             }
         } else {
-            int e = in.getE() - 15 + 127;
+            int e = static_cast<int>(in.getE()) - 15 + 127;
             unsigned int m = in.getM();
             out.setE(uint32_t(e));
             out.setM(m << 13);
@@ -142,8 +148,8 @@
     return out.fp;
 }
 
-inline /* constexpr */ android::half operator"" _hf(long double v) {
-    return android::half(android::half::binary, android::half::ftoh(v).bits);
+inline CONSTEXPR android::half operator"" _hf(long double v) {
+    return android::half(android::half::binary, android::half::ftoh(static_cast<float>(v)).bits);
 }
 
 } // namespace android
@@ -197,5 +203,6 @@
 
 #undef LIKELY
 #undef UNLIKELY
+#undef CONSTEXPR
 
 #endif // UI_HALF_H
diff --git a/include/ui/mat2.h b/include/ui/mat2.h
index 5ae73dc..37c7221 100644
--- a/include/ui/mat2.h
+++ b/include/ui/mat2.h
@@ -24,6 +24,12 @@
 
 #define PURE __attribute__((pure))
 
+#if __cplusplus >= 201402L
+#define CONSTEXPR constexpr
+#else
+#define CONSTEXPR
+#endif
+
 namespace android {
 // -------------------------------------------------------------------------------------
 namespace details {
@@ -130,8 +136,7 @@
     /**
      * leaves object uninitialized. use with caution.
      */
-    explicit
-    constexpr TMat22(no_init)
+    explicit constexpr TMat22(no_init)
             : m_value{ col_type(col_type::NO_INIT),
                        col_type(col_type::NO_INIT) } {}
 
@@ -148,7 +153,7 @@
      *      \right)
      *      \f$
      */
-    TMat22();
+    CONSTEXPR TMat22();
 
     /**
      * initialize to Identity*scalar.
@@ -163,7 +168,7 @@
      *      \f$
      */
     template<typename U>
-    explicit TMat22(U v);
+    explicit CONSTEXPR TMat22(U v);
 
     /**
      * sets the diagonal to a vector.
@@ -178,13 +183,13 @@
      *      \f$
      */
     template <typename U>
-    explicit TMat22(const TVec2<U>& v);
+    explicit CONSTEXPR TMat22(const TVec2<U>& v);
 
     /**
      * construct from another matrix of the same size
      */
     template <typename U>
-    explicit TMat22(const TMat22<U>& rhs);
+    explicit CONSTEXPR TMat22(const TMat22<U>& rhs);
 
     /**
      * construct from 2 column vectors.
@@ -198,7 +203,7 @@
      *      \f$
      */
     template <typename A, typename B>
-    TMat22(const TVec2<A>& v0, const TVec2<B>& v1);
+    CONSTEXPR TMat22(const TVec2<A>& v0, const TVec2<B>& v1);
 
     /** construct from 4 elements in column-major form.
      *
@@ -214,19 +219,18 @@
     template <
         typename A, typename B,
         typename C, typename D>
-    TMat22(A m00, B m01,
-           C m10, D m11);
+    CONSTEXPR TMat22(A m00, B m01, C m10, D m11);
 
     /**
      * construct from a C array in column major form.
      */
     template <typename U>
-    explicit TMat22(U const* rawArray);
+    explicit CONSTEXPR TMat22(U const* rawArray);
 
     /**
      * Rotate by radians in the 2D plane
      */
-    static TMat22<T> rotate(T radian) {
+    static CONSTEXPR TMat22<T> rotate(T radian) {
         TMat22<T> r(TMat22<T>::NO_INIT);
         T c = std::cos(radian);
         T s = std::sin(radian);
@@ -244,21 +248,21 @@
 // operations.
 
 template <typename T>
-TMat22<T>::TMat22() {
+CONSTEXPR TMat22<T>::TMat22() {
     m_value[0] = col_type(1, 0);
     m_value[1] = col_type(0, 1);
 }
 
 template <typename T>
 template <typename U>
-TMat22<T>::TMat22(U v) {
+CONSTEXPR TMat22<T>::TMat22(U v) {
     m_value[0] = col_type(v, 0);
     m_value[1] = col_type(0, v);
 }
 
 template<typename T>
 template<typename U>
-TMat22<T>::TMat22(const TVec2<U>& v) {
+CONSTEXPR TMat22<T>::TMat22(const TVec2<U>& v) {
     m_value[0] = col_type(v.x, 0);
     m_value[1] = col_type(0, v.y);
 }
@@ -270,15 +274,14 @@
 template <
     typename A, typename B,
     typename C, typename D>
-TMat22<T>::TMat22(A m00, B m01,
-                  C m10, D m11) {
+CONSTEXPR TMat22<T>::TMat22( A m00, B m01, C m10, D m11) {
     m_value[0] = col_type(m00, m01);
     m_value[1] = col_type(m10, m11);
 }
 
 template <typename T>
 template <typename U>
-TMat22<T>::TMat22(const TMat22<U>& rhs) {
+CONSTEXPR TMat22<T>::TMat22(const TMat22<U>& rhs) {
     for (size_t col = 0; col < NUM_COLS; ++col) {
         m_value[col] = col_type(rhs[col]);
     }
@@ -287,7 +290,7 @@
 // Construct from 2 column vectors.
 template <typename T>
 template <typename A, typename B>
-TMat22<T>::TMat22(const TVec2<A>& v0, const TVec2<B>& v1) {
+CONSTEXPR TMat22<T>::TMat22(const TVec2<A>& v0, const TVec2<B>& v1) {
     m_value[0] = v0;
     m_value[1] = v1;
 }
@@ -295,7 +298,7 @@
 // Construct from raw array, in column-major form.
 template <typename T>
 template <typename U>
-TMat22<T>::TMat22(U const* rawArray) {
+CONSTEXPR TMat22<T>::TMat22(U const* rawArray) {
     for (size_t col = 0; col < NUM_COLS; ++col) {
         for (size_t row = 0; row < NUM_ROWS; ++row) {
             m_value[col][row] = *rawArray++;
@@ -317,7 +320,7 @@
 
 // matrix * column-vector, result is a vector of the same type than the input vector
 template <typename T, typename U>
-typename TMat22<U>::col_type PURE operator *(const TMat22<T>& lhs, const TVec2<U>& rhs) {
+CONSTEXPR typename TMat22<U>::col_type PURE operator *(const TMat22<T>& lhs, const TVec2<U>& rhs) {
     // Result is initialized to zero.
     typename TMat22<U>::col_type result;
     for (size_t col = 0; col < TMat22<T>::NUM_COLS; ++col) {
@@ -328,7 +331,7 @@
 
 // row-vector * matrix, result is a vector of the same type than the input vector
 template <typename T, typename U>
-typename TMat22<U>::row_type PURE operator *(const TVec2<U>& lhs, const TMat22<T>& rhs) {
+CONSTEXPR typename TMat22<U>::row_type PURE operator *(const TVec2<U>& lhs, const TMat22<T>& rhs) {
     typename TMat22<U>::row_type result(TMat22<U>::row_type::NO_INIT);
     for (size_t col = 0; col < TMat22<T>::NUM_COLS; ++col) {
         result[col] = dot(lhs, rhs[col]);
@@ -356,7 +359,7 @@
  * BASE<T>::col_type is not accessible from there (???)
  */
 template<typename T>
-typename TMat22<T>::col_type PURE diag(const TMat22<T>& m) {
+CONSTEXPR typename TMat22<T>::col_type PURE diag(const TMat22<T>& m) {
     return matrix::diag(m);
 }
 
@@ -372,5 +375,6 @@
 }  // namespace android
 
 #undef PURE
+#undef CONSTEXPR
 
 #endif  // UI_MAT2_H_
diff --git a/include/ui/mat3.h b/include/ui/mat3.h
index 6a071c1..cd24a44 100644
--- a/include/ui/mat3.h
+++ b/include/ui/mat3.h
@@ -25,6 +25,12 @@
 
 #define PURE __attribute__((pure))
 
+#if __cplusplus >= 201402L
+#define CONSTEXPR constexpr
+#else
+#define CONSTEXPR
+#endif
+
 namespace android {
 // -------------------------------------------------------------------------------------
 namespace details {
@@ -137,8 +143,7 @@
     /**
      * leaves object uninitialized. use with caution.
      */
-    explicit
-    constexpr TMat33(no_init)
+    explicit constexpr TMat33(no_init)
             : m_value{ col_type(col_type::NO_INIT),
                        col_type(col_type::NO_INIT),
                        col_type(col_type::NO_INIT) } {}
@@ -157,7 +162,7 @@
      *      \right)
      *      \f$
      */
-    TMat33();
+    CONSTEXPR TMat33();
 
     /**
      * initialize to Identity*scalar.
@@ -173,7 +178,7 @@
      *      \f$
      */
     template<typename U>
-    explicit TMat33(U v);
+    explicit CONSTEXPR TMat33(U v);
 
     /**
      * sets the diagonal to a vector.
@@ -189,13 +194,13 @@
      *      \f$
      */
     template <typename U>
-    explicit TMat33(const TVec3<U>& v);
+    explicit CONSTEXPR TMat33(const TVec3<U>& v);
 
     /**
      * construct from another matrix of the same size
      */
     template <typename U>
-    explicit TMat33(const TMat33<U>& rhs);
+    explicit CONSTEXPR TMat33(const TMat33<U>& rhs);
 
     /**
      * construct from 3 column vectors.
@@ -209,7 +214,7 @@
      *      \f$
      */
     template <typename A, typename B, typename C>
-    TMat33(const TVec3<A>& v0, const TVec3<B>& v1, const TVec3<C>& v2);
+    CONSTEXPR TMat33(const TVec3<A>& v0, const TVec3<B>& v1, const TVec3<C>& v2);
 
     /** construct from 9 elements in column-major form.
      *
@@ -227,7 +232,8 @@
         typename A, typename B, typename C,
         typename D, typename E, typename F,
         typename G, typename H, typename I>
-    TMat33(A m00, B m01, C m02,
+    CONSTEXPR TMat33(
+           A m00, B m01, C m02,
            D m10, E m11, F m12,
            G m20, H m21, I m22);
 
@@ -235,19 +241,19 @@
      * construct from a quaternion
      */
     template <typename U>
-    explicit TMat33(const TQuaternion<U>& q);
+    explicit CONSTEXPR TMat33(const TQuaternion<U>& q);
 
     /**
      * construct from a C array in column major form.
      */
     template <typename U>
-    explicit TMat33(U const* rawArray);
+    explicit CONSTEXPR TMat33(U const* rawArray);
 
     /**
      * orthogonalize only works on matrices of size 3x3
      */
     friend inline
-    TMat33 orthogonalize(const TMat33& m) {
+    CONSTEXPR TMat33 orthogonalize(const TMat33& m) {
         TMat33 ret(TMat33::NO_INIT);
         ret[0] = normalize(m[0]);
         ret[2] = normalize(cross(ret[0], m[1]));
@@ -264,7 +270,7 @@
 // operations.
 
 template <typename T>
-TMat33<T>::TMat33() {
+CONSTEXPR TMat33<T>::TMat33() {
     m_value[0] = col_type(1, 0, 0);
     m_value[1] = col_type(0, 1, 0);
     m_value[2] = col_type(0, 0, 1);
@@ -272,7 +278,7 @@
 
 template <typename T>
 template <typename U>
-TMat33<T>::TMat33(U v) {
+CONSTEXPR TMat33<T>::TMat33(U v) {
     m_value[0] = col_type(v, 0, 0);
     m_value[1] = col_type(0, v, 0);
     m_value[2] = col_type(0, 0, v);
@@ -280,7 +286,7 @@
 
 template<typename T>
 template<typename U>
-TMat33<T>::TMat33(const TVec3<U>& v) {
+CONSTEXPR TMat33<T>::TMat33(const TVec3<U>& v) {
     m_value[0] = col_type(v.x, 0, 0);
     m_value[1] = col_type(0, v.y, 0);
     m_value[2] = col_type(0, 0, v.z);
@@ -294,9 +300,10 @@
     typename A, typename B, typename C,
     typename D, typename E, typename F,
     typename G, typename H, typename I>
-TMat33<T>::TMat33(A m00, B m01, C m02,
-                  D m10, E m11, F m12,
-                  G m20, H m21, I m22) {
+CONSTEXPR TMat33<T>::TMat33(
+        A m00, B m01, C m02,
+        D m10, E m11, F m12,
+        G m20, H m21, I m22) {
     m_value[0] = col_type(m00, m01, m02);
     m_value[1] = col_type(m10, m11, m12);
     m_value[2] = col_type(m20, m21, m22);
@@ -304,7 +311,7 @@
 
 template <typename T>
 template <typename U>
-TMat33<T>::TMat33(const TMat33<U>& rhs) {
+CONSTEXPR TMat33<T>::TMat33(const TMat33<U>& rhs) {
     for (size_t col = 0; col < NUM_COLS; ++col) {
         m_value[col] = col_type(rhs[col]);
     }
@@ -313,7 +320,7 @@
 // Construct from 3 column vectors.
 template <typename T>
 template <typename A, typename B, typename C>
-TMat33<T>::TMat33(const TVec3<A>& v0, const TVec3<B>& v1, const TVec3<C>& v2) {
+CONSTEXPR TMat33<T>::TMat33(const TVec3<A>& v0, const TVec3<B>& v1, const TVec3<C>& v2) {
     m_value[0] = v0;
     m_value[1] = v1;
     m_value[2] = v2;
@@ -322,7 +329,7 @@
 // Construct from raw array, in column-major form.
 template <typename T>
 template <typename U>
-TMat33<T>::TMat33(U const* rawArray) {
+CONSTEXPR TMat33<T>::TMat33(U const* rawArray) {
     for (size_t col = 0; col < NUM_COLS; ++col) {
         for (size_t row = 0; row < NUM_ROWS; ++row) {
             m_value[col][row] = *rawArray++;
@@ -332,7 +339,7 @@
 
 template <typename T>
 template <typename U>
-TMat33<T>::TMat33(const TQuaternion<U>& q) {
+CONSTEXPR TMat33<T>::TMat33(const TQuaternion<U>& q) {
     const U n = q.x*q.x + q.y*q.y + q.z*q.z + q.w*q.w;
     const U s = n > 0 ? 2/n : 0;
     const U x = s*q.x;
@@ -366,7 +373,7 @@
 
 // matrix * column-vector, result is a vector of the same type than the input vector
 template <typename T, typename U>
-typename TMat33<U>::col_type PURE operator *(const TMat33<T>& lhs, const TVec3<U>& rhs) {
+CONSTEXPR typename TMat33<U>::col_type PURE operator *(const TMat33<T>& lhs, const TVec3<U>& rhs) {
     // Result is initialized to zero.
     typename TMat33<U>::col_type result;
     for (size_t col = 0; col < TMat33<T>::NUM_COLS; ++col) {
@@ -377,7 +384,7 @@
 
 // row-vector * matrix, result is a vector of the same type than the input vector
 template <typename T, typename U>
-typename TMat33<U>::row_type PURE operator *(const TVec3<U>& lhs, const TMat33<T>& rhs) {
+CONSTEXPR typename TMat33<U>::row_type PURE operator *(const TVec3<U>& lhs, const TMat33<T>& rhs) {
     typename TMat33<U>::row_type result(TMat33<U>::row_type::NO_INIT);
     for (size_t col = 0; col < TMat33<T>::NUM_COLS; ++col) {
         result[col] = dot(lhs, rhs[col]);
@@ -401,7 +408,7 @@
 
 //------------------------------------------------------------------------------
 template <typename T>
-TMat33<T> orthogonalize(const TMat33<T>& m) {
+CONSTEXPR TMat33<T> orthogonalize(const TMat33<T>& m) {
     TMat33<T> ret(TMat33<T>::NO_INIT);
     ret[0] = normalize(m[0]);
     ret[2] = normalize(cross(ret[0], m[1]));
@@ -415,7 +422,7 @@
  * BASE<T>::col_type is not accessible from there (???)
  */
 template<typename T>
-typename TMat33<T>::col_type PURE diag(const TMat33<T>& m) {
+CONSTEXPR typename TMat33<T>::col_type PURE diag(const TMat33<T>& m) {
     return matrix::diag(m);
 }
 
@@ -431,5 +438,6 @@
 }  // namespace android
 
 #undef PURE
+#undef CONSTEXPR
 
 #endif  // UI_MAT3_H_
diff --git a/include/ui/mat4.h b/include/ui/mat4.h
index a607023..f63d40a 100644
--- a/include/ui/mat4.h
+++ b/include/ui/mat4.h
@@ -29,6 +29,12 @@
 
 #define PURE __attribute__((pure))
 
+#if __cplusplus >= 201402L
+#define CONSTEXPR constexpr
+#else
+#define CONSTEXPR
+#endif
+
 namespace android {
 // -------------------------------------------------------------------------------------
 namespace details {
@@ -141,8 +147,7 @@
      */
 
     // leaves object uninitialized. use with caution.
-    explicit
-    constexpr TMat44(no_init)
+    explicit constexpr TMat44(no_init)
             : m_value{ col_type(col_type::NO_INIT),
                        col_type(col_type::NO_INIT),
                        col_type(col_type::NO_INIT),
@@ -161,7 +166,7 @@
      *      \right)
      *      \f$
      */
-    TMat44();
+    CONSTEXPR TMat44();
 
     /** initialize to Identity*scalar.
      *
@@ -177,7 +182,7 @@
      *      \f$
      */
     template<typename U>
-    explicit TMat44(U v);
+    explicit CONSTEXPR TMat44(U v);
 
     /** sets the diagonal to a vector.
      *
@@ -193,11 +198,11 @@
      *      \f$
      */
     template <typename U>
-    explicit TMat44(const TVec4<U>& v);
+    explicit CONSTEXPR TMat44(const TVec4<U>& v);
 
     // construct from another matrix of the same size
     template <typename U>
-    explicit TMat44(const TMat44<U>& rhs);
+    explicit CONSTEXPR TMat44(const TMat44<U>& rhs);
 
     /** construct from 4 column vectors.
      *
@@ -210,7 +215,7 @@
      *      \f$
      */
     template <typename A, typename B, typename C, typename D>
-    TMat44(const TVec4<A>& v0, const TVec4<B>& v1, const TVec4<C>& v2, const TVec4<D>& v3);
+    CONSTEXPR TMat44(const TVec4<A>& v0, const TVec4<B>& v1, const TVec4<C>& v2, const TVec4<D>& v3);
 
     /** construct from 16 elements in column-major form.
      *
@@ -230,66 +235,67 @@
         typename E, typename F, typename G, typename H,
         typename I, typename J, typename K, typename L,
         typename M, typename N, typename O, typename P>
-    TMat44(A m00, B m01, C m02, D m03,
-           E m10, F m11, G m12, H m13,
-           I m20, J m21, K m22, L m23,
-           M m30, N m31, O m32, P m33);
+    CONSTEXPR TMat44(
+            A m00, B m01, C m02, D m03,
+            E m10, F m11, G m12, H m13,
+            I m20, J m21, K m22, L m23,
+            M m30, N m31, O m32, P m33);
 
     /**
      * construct from a quaternion
      */
     template <typename U>
-    explicit TMat44(const TQuaternion<U>& q);
+    explicit CONSTEXPR TMat44(const TQuaternion<U>& q);
 
     /**
      * construct from a C array in column major form.
      */
     template <typename U>
-    explicit TMat44(U const* rawArray);
+    explicit CONSTEXPR TMat44(U const* rawArray);
 
     /**
      * construct from a 3x3 matrix
      */
     template <typename U>
-    explicit TMat44(const TMat33<U>& matrix);
+    explicit CONSTEXPR TMat44(const TMat33<U>& matrix);
 
     /**
      * construct from a 3x3 matrix and 3d translation
      */
     template <typename U, typename V>
-    TMat44(const TMat33<U>& matrix, const TVec3<V>& translation);
+    CONSTEXPR TMat44(const TMat33<U>& matrix, const TVec3<V>& translation);
 
     /**
      * construct from a 3x3 matrix and 4d last column.
      */
     template <typename U, typename V>
-    TMat44(const TMat33<U>& matrix, const TVec4<V>& column3);
+    CONSTEXPR TMat44(const TMat33<U>& matrix, const TVec4<V>& column3);
 
     /*
      *  helpers
      */
 
-    static TMat44 ortho(T left, T right, T bottom, T top, T near, T far);
+    static CONSTEXPR TMat44 ortho(T left, T right, T bottom, T top, T near, T far);
 
-    static TMat44 frustum(T left, T right, T bottom, T top, T near, T far);
+    static CONSTEXPR TMat44 frustum(T left, T right, T bottom, T top, T near, T far);
 
     enum class Fov {
         HORIZONTAL,
         VERTICAL
     };
-    static TMat44 perspective(T fov, T aspect, T near, T far, Fov direction = Fov::VERTICAL);
+    static CONSTEXPR TMat44 perspective(T fov, T aspect, T near, T far, Fov direction = Fov::VERTICAL);
 
     template <typename A, typename B, typename C>
-    static TMat44 lookAt(const TVec3<A>& eye, const TVec3<B>& center, const TVec3<C>& up);
+    static CONSTEXPR TMat44 lookAt(const TVec3<A>& eye, const TVec3<B>& center, const TVec3<C>& up);
 
     template <typename A>
-    static TVec3<A> project(const TMat44& projectionMatrix, TVec3<A> vertice) {
+    static CONSTEXPR TVec3<A> project(const TMat44& projectionMatrix, TVec3<A> vertice) {
         TVec4<A> r = projectionMatrix * TVec4<A>{ vertice, 1 };
         return r.xyz / r.w;
     }
 
     template <typename A>
-    static TVec4<A> project(const TMat44& projectionMatrix, TVec4<A> vertice) {
+    static CONSTEXPR TVec4<A> project(const TMat44& projectionMatrix, TVec4<A> vertice) {
         vertice = projectionMatrix * vertice;
         return { vertice.xyz / vertice.w, 1 };
     }
@@ -310,7 +316,7 @@
 // operations.
 
 template <typename T>
-TMat44<T>::TMat44() {
+CONSTEXPR TMat44<T>::TMat44() {
     m_value[0] = col_type(1, 0, 0, 0);
     m_value[1] = col_type(0, 1, 0, 0);
     m_value[2] = col_type(0, 0, 1, 0);
@@ -319,7 +325,7 @@
 
 template <typename T>
 template <typename U>
-TMat44<T>::TMat44(U v) {
+CONSTEXPR TMat44<T>::TMat44(U v) {
     m_value[0] = col_type(v, 0, 0, 0);
     m_value[1] = col_type(0, v, 0, 0);
     m_value[2] = col_type(0, 0, v, 0);
@@ -328,7 +334,7 @@
 
 template<typename T>
 template<typename U>
-TMat44<T>::TMat44(const TVec4<U>& v) {
+CONSTEXPR TMat44<T>::TMat44(const TVec4<U>& v) {
     m_value[0] = col_type(v.x, 0, 0, 0);
     m_value[1] = col_type(0, v.y, 0, 0);
     m_value[2] = col_type(0, 0, v.z, 0);
@@ -342,10 +348,11 @@
     typename E, typename F, typename G, typename H,
     typename I, typename J, typename K, typename L,
     typename M, typename N, typename O, typename P>
-TMat44<T>::TMat44(A m00, B m01, C m02, D m03,
-                  E m10, F m11, G m12, H m13,
-                  I m20, J m21, K m22, L m23,
-                  M m30, N m31, O m32, P m33) {
+CONSTEXPR TMat44<T>::TMat44(
+        A m00, B m01, C m02, D m03,
+        E m10, F m11, G m12, H m13,
+        I m20, J m21, K m22, L m23,
+        M m30, N m31, O m32, P m33) {
     m_value[0] = col_type(m00, m01, m02, m03);
     m_value[1] = col_type(m10, m11, m12, m13);
     m_value[2] = col_type(m20, m21, m22, m23);
@@ -354,7 +361,7 @@
 
 template <typename T>
 template <typename U>
-TMat44<T>::TMat44(const TMat44<U>& rhs) {
+CONSTEXPR TMat44<T>::TMat44(const TMat44<U>& rhs) {
     for (size_t col = 0; col < NUM_COLS; ++col) {
         m_value[col] = col_type(rhs[col]);
     }
@@ -363,7 +370,9 @@
 // Construct from 4 column vectors.
 template <typename T>
 template <typename A, typename B, typename C, typename D>
-TMat44<T>::TMat44(const TVec4<A>& v0, const TVec4<B>& v1, const TVec4<C>& v2, const TVec4<D>& v3) {
+CONSTEXPR TMat44<T>::TMat44(
+        const TVec4<A>& v0, const TVec4<B>& v1,
+        const TVec4<C>& v2, const TVec4<D>& v3) {
     m_value[0] = col_type(v0);
     m_value[1] = col_type(v1);
     m_value[2] = col_type(v2);
@@ -373,7 +382,7 @@
 // Construct from raw array, in column-major form.
 template <typename T>
 template <typename U>
-TMat44<T>::TMat44(U const* rawArray) {
+CONSTEXPR TMat44<T>::TMat44(U const* rawArray) {
     for (size_t col = 0; col < NUM_COLS; ++col) {
         for (size_t row = 0; row < NUM_ROWS; ++row) {
             m_value[col][row] = *rawArray++;
@@ -383,7 +392,7 @@
 
 template <typename T>
 template <typename U>
-TMat44<T>::TMat44(const TQuaternion<U>& q) {
+CONSTEXPR TMat44<T>::TMat44(const TQuaternion<U>& q) {
     const U n = q.x*q.x + q.y*q.y + q.z*q.z + q.w*q.w;
     const U s = n > 0 ? 2/n : 0;
     const U x = s*q.x;
@@ -406,7 +415,7 @@
 
 template <typename T>
 template <typename U>
-TMat44<T>::TMat44(const TMat33<U>& m) {
+CONSTEXPR TMat44<T>::TMat44(const TMat33<U>& m) {
     m_value[0] = col_type(m[0][0], m[0][1], m[0][2], 0);
     m_value[1] = col_type(m[1][0], m[1][1], m[1][2], 0);
     m_value[2] = col_type(m[2][0], m[2][1], m[2][2], 0);
@@ -415,7 +424,7 @@
 
 template <typename T>
 template <typename U, typename V>
-TMat44<T>::TMat44(const TMat33<U>& m, const TVec3<V>& v) {
+CONSTEXPR TMat44<T>::TMat44(const TMat33<U>& m, const TVec3<V>& v) {
     m_value[0] = col_type(m[0][0], m[0][1], m[0][2], 0);
     m_value[1] = col_type(m[1][0], m[1][1], m[1][2], 0);
     m_value[2] = col_type(m[2][0], m[2][1], m[2][2], 0);
@@ -424,7 +433,7 @@
 
 template <typename T>
 template <typename U, typename V>
-TMat44<T>::TMat44(const TMat33<U>& m, const TVec4<V>& v) {
+CONSTEXPR TMat44<T>::TMat44(const TMat33<U>& m, const TVec4<V>& v) {
     m_value[0] = col_type(m[0][0], m[0][1], m[0][2],    0);  // NOLINT
     m_value[1] = col_type(m[1][0], m[1][1], m[1][2],    0);  // NOLINT
     m_value[2] = col_type(m[2][0], m[2][1], m[2][2],    0);  // NOLINT
@@ -436,7 +445,7 @@
 // ----------------------------------------------------------------------------------------
 
 template <typename T>
-TMat44<T> TMat44<T>::ortho(T left, T right, T bottom, T top, T near, T far) {
+CONSTEXPR TMat44<T> TMat44<T>::ortho(T left, T right, T bottom, T top, T near, T far) {
     TMat44<T> m;
     m[0][0] =  2 / (right - left);
     m[1][1] =  2 / (top   - bottom);
@@ -448,7 +457,7 @@
 }
 
 template <typename T>
-TMat44<T> TMat44<T>::frustum(T left, T right, T bottom, T top, T near, T far) {
+CONSTEXPR TMat44<T> TMat44<T>::frustum(T left, T right, T bottom, T top, T near, T far) {
     TMat44<T> m;
     m[0][0] =  (2 * near) / (right - left);
     m[1][1] =  (2 * near) / (top   - bottom);
@@ -462,7 +471,7 @@
 }
 
 template <typename T>
-TMat44<T> TMat44<T>::perspective(T fov, T aspect, T near, T far, TMat44::Fov direction) {
+CONSTEXPR TMat44<T> TMat44<T>::perspective(T fov, T aspect, T near, T far, TMat44::Fov direction) {
     T h;
     T w;
 
@@ -483,7 +492,7 @@
  */
 template <typename T>
 template <typename A, typename B, typename C>
-TMat44<T> TMat44<T>::lookAt(const TVec3<A>& eye, const TVec3<B>& center, const TVec3<C>& up) {
+CONSTEXPR TMat44<T> TMat44<T>::lookAt(const TVec3<A>& eye, const TVec3<B>& center, const TVec3<C>& up) {
     TVec3<T> z_axis(normalize(center - eye));
     TVec3<T> norm_up(normalize(up));
     if (std::abs(dot(z_axis, norm_up)) > 0.999) {
@@ -513,7 +522,7 @@
 
 // matrix * column-vector, result is a vector of the same type than the input vector
 template <typename T, typename U>
-typename TMat44<T>::col_type PURE operator *(const TMat44<T>& lhs, const TVec4<U>& rhs) {
+CONSTEXPR typename TMat44<T>::col_type PURE operator *(const TMat44<T>& lhs, const TVec4<U>& rhs) {
     // Result is initialized to zero.
     typename TMat44<T>::col_type result;
     for (size_t col = 0; col < TMat44<T>::NUM_COLS; ++col) {
@@ -524,14 +533,14 @@
 
 // mat44 * vec3, result is vec3( mat44 * {vec3, 1} )
 template <typename T, typename U>
-typename TMat44<T>::col_type PURE operator *(const TMat44<T>& lhs, const TVec3<U>& rhs) {
+CONSTEXPR typename TMat44<T>::col_type PURE operator *(const TMat44<T>& lhs, const TVec3<U>& rhs) {
     return lhs * TVec4<U>{ rhs, 1 };
 }
 
 
 // row-vector * matrix, result is a vector of the same type than the input vector
 template <typename T, typename U>
-typename TMat44<U>::row_type PURE operator *(const TVec4<U>& lhs, const TMat44<T>& rhs) {
+CONSTEXPR typename TMat44<U>::row_type PURE operator *(const TVec4<U>& lhs, const TMat44<T>& rhs) {
     typename TMat44<U>::row_type result(TMat44<U>::row_type::NO_INIT);
     for (size_t col = 0; col < TMat44<T>::NUM_COLS; ++col) {
         result[col] = dot(lhs, rhs[col]);
@@ -575,5 +584,6 @@
 }  // namespace android
 
 #undef PURE
+#undef CONSTEXPR
 
 #endif  // UI_MAT4_H_
diff --git a/include/ui/quat.h b/include/ui/quat.h
index 8c89cd7..5b8cd8b 100644
--- a/include/ui/quat.h
+++ b/include/ui/quat.h
@@ -29,6 +29,10 @@
 #define PURE __attribute__((pure))
 #endif
 
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wgnu-anonymous-struct"
+#pragma clang diagnostic ignored "-Wnested-anon-types"
+
 namespace android {
 // -------------------------------------------------------------------------------------
 
@@ -142,48 +146,50 @@
 typedef details::TQuaternion<half> quath;
 
 constexpr inline quat operator"" _i(long double v) {
-    return quat(0, v, 0, 0);
+    return quat(0, static_cast<float>(v), 0, 0);
 }
 constexpr inline quat operator"" _j(long double v) {
-    return quat(0, 0, v, 0);
+    return quat(0, 0, static_cast<float>(v), 0);
 }
 constexpr inline quat operator"" _k(long double v) {
-    return quat(0, 0, 0, v);
+    return quat(0, 0, 0, static_cast<float>(v));
 }
 
 constexpr inline quat operator"" _i(unsigned long long v) {  // NOLINT
-    return quat(0, v, 0, 0);
+    return quat(0, static_cast<float>(v), 0, 0);
 }
 constexpr inline quat operator"" _j(unsigned long long v) {  // NOLINT
-    return quat(0, 0, v, 0);
+    return quat(0, 0, static_cast<float>(v), 0);
 }
 constexpr inline quat operator"" _k(unsigned long long v) {  // NOLINT
-    return quat(0, 0, 0, v);
+    return quat(0, 0, 0, static_cast<float>(v));
 }
 
 constexpr inline quatd operator"" _id(long double v) {
-    return quatd(0, v, 0, 0);
+    return quatd(0, static_cast<double>(v), 0, 0);
 }
 constexpr inline quatd operator"" _jd(long double v) {
-    return quatd(0, 0, v, 0);
+    return quatd(0, 0, static_cast<double>(v), 0);
 }
 constexpr inline quatd operator"" _kd(long double v) {
-    return quatd(0, 0, 0, v);
+    return quatd(0, 0, 0, static_cast<double>(v));
 }
 
 constexpr inline quatd operator"" _id(unsigned long long v) {  // NOLINT
-    return quatd(0, v, 0, 0);
+    return quatd(0, static_cast<double>(v), 0, 0);
 }
 constexpr inline quatd operator"" _jd(unsigned long long v) {  // NOLINT
-    return quatd(0, 0, v, 0);
+    return quatd(0, 0, static_cast<double>(v), 0);
 }
 constexpr inline quatd operator"" _kd(unsigned long long v) {  // NOLINT
-    return quatd(0, 0, 0, v);
+    return quatd(0, 0, 0, static_cast<double>(v));
 }
 
 // ----------------------------------------------------------------------------------------
 }  // namespace android
 
+#pragma clang diagnostic pop
+
 #undef PURE
 
 #endif  // UI_QUAT_H_
diff --git a/include/ui/scalar.h b/include/ui/scalar.h
index c938d5c..5f8329e 100644
--- a/include/ui/scalar.h
+++ b/include/ui/scalar.h
@@ -42,126 +42,6 @@
     return mix(x, y, a);
 }
 
-namespace details {
-    static int asInt(float x) {
-        return *reinterpret_cast<int*>(&x);
-    }
-
-    static float asFloat(int x) {
-        return *reinterpret_cast<float*>(&x);
-    }
-
-    static constexpr float inversesqrtNewtonRaphson(float x, float inverseSqrtX) {
-        return inverseSqrtX * (-x * 0.5f * (inverseSqrtX * inverseSqrtX) + 1.5f);
-    }
-
-    static constexpr float rcpNewtonRaphson(float x, float rcpX) {
-        return rcpX * (-rcpX * x + 2.0f);
-    }
-
-    static const float inverseSqrtFast(float f, int c) {
-        int v = details::asInt(f);
-        v = c - (v >> 1);
-        return details::asFloat(v);
-    }
-
-    static const float rcpFast(float f, int c) {
-        int v = details::asInt(f);
-        v = c - v;
-        return details::asFloat(v);
-    }
-} // namespace details
-
-/**
- * Approximates an inverse square root using a specified
- * number of Newton-Raphson iterations. The number of iterations
- * can be:
- *
- * - 0, with a precision of ~3.4% over the full range
- * - 1, with a precision of ~0.2% over the full range
- * - 2, with a precision of ~4e-4% over the full range
- */
-template<int>
-static float inversesqrtFast(float f) noexcept;
-
-template<>
-float inversesqrtFast<0>(float f) noexcept {
-    return details::inverseSqrtFast(f, 0x5f3759df);
-}
-
-template<>
-float inversesqrtFast<1>(float f) noexcept {
-    float x = details::inverseSqrtFast(f, 0x5f375a86);
-    return details::inversesqrtNewtonRaphson(f, x);
-}
-
-template<>
-float inversesqrtFast<2>(float f) noexcept {
-    float x = details::inverseSqrtFast(f, 0x5f375a86);
-    x = details::inversesqrtNewtonRaphson(f, x);
-    x = details::inversesqrtNewtonRaphson(f, x);
-    return x;
-}
-
-/**
- * Approximates a square root using a specified number of
- * Newton-Raphson iterations. The number of iterations can be:
- *
- * - 0, with a precision of ~0.7% over the full range
- * - 1, with a precision of ~0.2% over the full range
- * - 2, with a precision of ~4e-4% over the full range
- */
-template<int>
-static float sqrtFast(float f) noexcept;
-
-template<>
-float sqrtFast<0>(float f) noexcept {
-    int v = details::asInt(f);
-    v = 0x1fbd1df5 + (v >> 1);
-    return details::asFloat(v);
-}
-
-template<>
-float sqrtFast<1>(float f) noexcept {
-    return f * inversesqrtFast<1>(f);
-}
-
-template<>
-float sqrtFast<2>(float f) noexcept {
-    return f * inversesqrtFast<2>(f);
-}
-
-/**
- * Approximates a reciprocal using a specified number
- * of Newton-Raphson iterations. The number of iterations
- * can be:
- *
- * - 0, with a precision of ~0.4% over the full range
- * - 1, with a precision of ~0.02% over the full range
- * - 2, with a precision of ~5e-5% over the full range
- */
-template<int>
-static float rcpFast(float f) noexcept;
-
-template<>
-float rcpFast<0>(float f) noexcept {
-    return details::rcpFast(f, 0x7ef311c2);
-}
-
-template<>
-float rcpFast<1>(float f) noexcept {
-    float x = details::rcpFast(f, 0x7ef311c3);
-    return details::rcpNewtonRaphson(f, x);
-}
-
-template<>
-float rcpFast<2>(float f) noexcept {
-    float x = details::rcpFast(f, 0x7ef312ac);
-    x = details::rcpNewtonRaphson(f, x);
-    x = details::rcpNewtonRaphson(f, x);
-    return x;
-}
-
 } // namespace std
 
 #endif // UI_SCALAR_H
diff --git a/include/ui/vec2.h b/include/ui/vec2.h
index a88d026..fdd2e20 100644
--- a/include/ui/vec2.h
+++ b/include/ui/vec2.h
@@ -24,6 +24,9 @@
 #include <sys/types.h>
 #include <type_traits>
 
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wgnu-anonymous-struct"
+#pragma clang diagnostic ignored "-Wnested-anon-types"
 
 namespace android {
 // -------------------------------------------------------------------------------------
@@ -94,7 +97,7 @@
     constexpr TVec2(const TVec2<A>& v) : x(v.x), y(v.y) { }
 
     // cross product works only on vectors of size 2 or 3
-    template <typename RT>
+    template<typename RT>
     friend inline
     constexpr value_type cross(const TVec2& u, const TVec2<RT>& v) {
         return value_type(u.x*v.y - u.y*v.x);
@@ -119,4 +122,6 @@
 // ----------------------------------------------------------------------------------------
 }  // namespace android
 
+#pragma clang diagnostic pop
+
 #endif  // UI_VEC2_H_
diff --git a/include/ui/vec3.h b/include/ui/vec3.h
index 0254f5a..f76b2ec 100644
--- a/include/ui/vec3.h
+++ b/include/ui/vec3.h
@@ -22,6 +22,9 @@
 #include <stdint.h>
 #include <sys/types.h>
 
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wgnu-anonymous-struct"
+#pragma clang diagnostic ignored "-Wnested-anon-types"
 
 namespace android {
 // -------------------------------------------------------------------------------------
@@ -125,4 +128,6 @@
 // ----------------------------------------------------------------------------------------
 }  // namespace android
 
+#pragma clang diagnostic pop
+
 #endif  // UI_VEC3_H_
diff --git a/include/ui/vec4.h b/include/ui/vec4.h
index 1281aa4..e13ad96 100644
--- a/include/ui/vec4.h
+++ b/include/ui/vec4.h
@@ -22,6 +22,9 @@
 #include <stdint.h>
 #include <sys/types.h>
 
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wgnu-anonymous-struct"
+#pragma clang diagnostic ignored "-Wnested-anon-types"
 
 namespace android {
 // -------------------------------------------------------------------------------------
@@ -122,4 +125,6 @@
 // ----------------------------------------------------------------------------------------
 }  // namespace android
 
+#pragma clang diagnostic pop
+
 #endif  // UI_VEC4_H_