diff --git a/glm/detail/_noise.hpp b/glm/detail/_noise.hpp
index d7d7d186..9b36db69 100644
--- a/glm/detail/_noise.hpp
+++ b/glm/detail/_noise.hpp
@@ -11,93 +11,93 @@
 namespace glm{
 namespace detail
 {
-	template <typename T>
+	template<typename T>
 	GLM_FUNC_QUALIFIER T mod289(T const & x)
 	{
 		return x - floor(x * (static_cast<T>(1.0) / static_cast<T>(289.0))) * static_cast<T>(289.0);
 	}
 
-	template <typename T>
+	template<typename T>
 	GLM_FUNC_QUALIFIER T permute(T const & x)
 	{
 		return mod289(((x * static_cast<T>(34)) + static_cast<T>(1)) * x);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P> permute(tvec2<T, P> const & x)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<2, T, P> permute(vec<2, T, P> const & x)
 	{
 		return mod289(((x * static_cast<T>(34)) + static_cast<T>(1)) * x);
 	}
 	
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> permute(tvec3<T, P> const & x)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> permute(vec<3, T, P> const & x)
 	{
 		return mod289(((x * static_cast<T>(34)) + static_cast<T>(1)) * x);
 	}
 	
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> permute(tvec4<T, P> const & x)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, T, P> permute(vec<4, T, P> const & x)
 	{
 		return mod289(((x * static_cast<T>(34)) + static_cast<T>(1)) * x);
 	}
 /*
-	template <typename T, precision P, template<typename> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> permute(vecType<T, P> const & x)
+	template<typename T, precision P, template<typename> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> permute(vecType<L, T, P> const & x)
 	{
 		return mod289(((x * T(34)) + T(1)) * x);
 	}
 */
-	template <typename T>
+	template<typename T>
 	GLM_FUNC_QUALIFIER T taylorInvSqrt(T const & r)
 	{
 		return T(1.79284291400159) - T(0.85373472095314) * r;
 	}
 	
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P> taylorInvSqrt(tvec2<T, P> const & r)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<2, T, P> taylorInvSqrt(vec<2, T, P> const & r)
 	{
 		return T(1.79284291400159) - T(0.85373472095314) * r;
 	}
 	
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> taylorInvSqrt(tvec3<T, P> const & r)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> taylorInvSqrt(vec<3, T, P> const & r)
 	{
 		return T(1.79284291400159) - T(0.85373472095314) * r;
 	}
 	
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> taylorInvSqrt(tvec4<T, P> const & r)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, T, P> taylorInvSqrt(vec<4, T, P> const & r)
 	{
 		return T(1.79284291400159) - T(0.85373472095314) * r;
 	}
 /*
-	template <typename T, precision P, template<typename> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> taylorInvSqrt(vecType<T, P> const & r)
+	template<typename T, precision P, template<typename> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> taylorInvSqrt(vecType<L, T, P> const & r)
 	{
 		return T(1.79284291400159) - T(0.85373472095314) * r;
 	}
 */
 	
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P> fade(tvec2<T, P> const & t)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<2, T, P> fade(vec<2, T, P> const & t)
 	{
 		return (t * t * t) * (t * (t * T(6) - T(15)) + T(10));
 	}
 	
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> fade(tvec3<T, P> const & t)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> fade(vec<3, T, P> const & t)
 	{
 		return (t * t * t) * (t * (t * T(6) - T(15)) + T(10));
 	}
 	
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> fade(tvec4<T, P> const & t)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, T, P> fade(vec<4, T, P> const & t)
 	{
 		return (t * t * t) * (t * (t * T(6) - T(15)) + T(10));
 	}
 /*
-	template <typename T, precision P, template <typename> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> fade(vecType<T, P> const & t)
+	template<typename T, precision P, template<typename> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> fade(vecType<L, T, P> const & t)
 	{
 		return (t * t * t) * (t * (t * T(6) - T(15)) + T(10));
 	}
diff --git a/glm/detail/_swizzle.hpp b/glm/detail/_swizzle.hpp
index 8e134d90..f404f5da 100644
--- a/glm/detail/_swizzle.hpp
+++ b/glm/detail/_swizzle.hpp
@@ -7,7 +7,7 @@ namespace glm{
 namespace detail
 {
 	// Internal class for implementing swizzle operators
-	template <typename T, int N>
+	template<typename T, int N>
 	struct _swizzle_base0
 	{
 	protected:
@@ -20,27 +20,27 @@ namespace detail
 		char    _buffer[1];
 	};
 
-	template <int N, typename T, precision P, template <typename, precision> class vecType, int E0, int E1, int E2, int E3, bool Aligned>
+	template<int N, typename T, precision P, int E0, int E1, int E2, int E3, bool Aligned>
 	struct _swizzle_base1 : public _swizzle_base0<T, N>
 	{
 	};
 
-	template <typename T, precision P, template <typename, precision> class vecType, int E0, int E1, bool Aligned>
-	struct _swizzle_base1<2, T, P, vecType, E0,E1,-1,-2, Aligned> : public _swizzle_base0<T, 2>
+	template<typename T, precision P, int E0, int E1, bool Aligned>
+	struct _swizzle_base1<2, T, P, E0,E1,-1,-2, Aligned> : public _swizzle_base0<T, 2>
 	{
-		GLM_FUNC_QUALIFIER vecType<T, P> operator ()()  const { return vecType<T, P>(this->elem(E0), this->elem(E1)); }
+		GLM_FUNC_QUALIFIER vec<2, T, P> operator ()()  const { return vec<2, T, P>(this->elem(E0), this->elem(E1)); }
 	};
 
-	template <typename T, precision P, template <typename, precision> class vecType, int E0, int E1, int E2, bool Aligned>
-	struct _swizzle_base1<3, T, P, vecType, E0,E1,E2,-1, Aligned> : public _swizzle_base0<T, 3>
+	template<typename T, precision P, int E0, int E1, int E2, bool Aligned>
+	struct _swizzle_base1<3, T, P, E0,E1,E2,-1, Aligned> : public _swizzle_base0<T, 3>
 	{
-		GLM_FUNC_QUALIFIER vecType<T, P> operator ()()  const { return vecType<T, P>(this->elem(E0), this->elem(E1), this->elem(E2)); }
+		GLM_FUNC_QUALIFIER vec<3, T, P> operator ()()  const { return vec<3, T, P>(this->elem(E0), this->elem(E1), this->elem(E2)); }
 	};
 
-	template <typename T, precision P, template <typename, precision> class vecType, int E0, int E1, int E2, int E3, bool Aligned>
-	struct _swizzle_base1<4, T, P, vecType, E0,E1,E2,E3, Aligned> : public _swizzle_base0<T, 4>
+	template<typename T, precision P, int E0, int E1, int E2, int E3, bool Aligned>
+	struct _swizzle_base1<4, T, P, E0,E1,E2,E3, Aligned> : public _swizzle_base0<T, 4>
 	{ 
-		GLM_FUNC_QUALIFIER vecType<T, P> operator ()()  const { return vecType<T, P>(this->elem(E0), this->elem(E1), this->elem(E2), this->elem(E3)); }
+		GLM_FUNC_QUALIFIER vec<4, T, P> operator ()()  const { return vec<4, T, P>(this->elem(E0), this->elem(E1), this->elem(E2), this->elem(E3)); }
 	};
 
 	// Internal class for implementing swizzle operators
@@ -48,15 +48,15 @@ namespace detail
 		Template parameters:
 
 		ValueType = type of scalar values (e.g. float, double)
-		VecType   = class the swizzle is applies to (e.g. tvec3<float>)
+		VecType   = class the swizzle is applies to (e.g. vec<3, float>)
 		N         = number of components in the vector (e.g. 3)
 		E0...3    = what index the n-th element of this swizzle refers to in the unswizzled vec
 
 		DUPLICATE_ELEMENTS = 1 if there is a repeated element, 0 otherwise (used to specialize swizzles
 			containing duplicate elements so that they cannot be used as r-values).            
 	*/
-	template <int N, typename T, precision P, template <typename, precision> class vecType, int E0, int E1, int E2, int E3, int DUPLICATE_ELEMENTS>
-	struct _swizzle_base2 : public _swizzle_base1<N, T, P, vecType, E0,E1,E2,E3, detail::is_aligned<P>::value>
+	template<int N, typename T, precision P, int E0, int E1, int E2, int E3, int DUPLICATE_ELEMENTS>
+	struct _swizzle_base2 : public _swizzle_base1<N, T, P, E0,E1,E2,E3, detail::is_aligned<P>::value>
 	{
 		GLM_FUNC_QUALIFIER _swizzle_base2& operator= (const T& t)
 		{
@@ -65,7 +65,7 @@ namespace detail
 			return *this;
 		}
 
-		GLM_FUNC_QUALIFIER _swizzle_base2& operator= (vecType<T, P> const& that)
+		GLM_FUNC_QUALIFIER _swizzle_base2& operator= (vec<N, T, P> const& that)
 		{
 			struct op { 
 				GLM_FUNC_QUALIFIER void operator() (T& e, T& t) { e = t; } 
@@ -74,7 +74,7 @@ namespace detail
 			return *this;
 		}
 
-		GLM_FUNC_QUALIFIER void operator -= (vecType<T, P> const& that)
+		GLM_FUNC_QUALIFIER void operator -= (vec<N, T, P> const& that)
 		{
 			struct op { 
 				GLM_FUNC_QUALIFIER void operator() (T& e, T& t) { e -= t; } 
@@ -82,7 +82,7 @@ namespace detail
 			_apply_op(that, op());
 		}
 
-		GLM_FUNC_QUALIFIER void operator += (vecType<T, P> const& that)
+		GLM_FUNC_QUALIFIER void operator += (vec<N, T, P> const& that)
 		{
 			struct op { 
 				GLM_FUNC_QUALIFIER void operator() (T& e, T& t) { e += t; } 
@@ -90,7 +90,7 @@ namespace detail
 			_apply_op(that, op());
 		}
 
-		GLM_FUNC_QUALIFIER void operator *= (vecType<T, P> const& that)
+		GLM_FUNC_QUALIFIER void operator *= (vec<N, T, P> const& that)
 		{
 			struct op { 
 				GLM_FUNC_QUALIFIER void operator() (T& e, T& t) { e *= t; } 
@@ -98,7 +98,7 @@ namespace detail
 			_apply_op(that, op());
 		}
 
-		GLM_FUNC_QUALIFIER void operator /= (vecType<T, P> const& that)
+		GLM_FUNC_QUALIFIER void operator /= (vec<N, T, P> const& that)
 		{
 			struct op { 
 				GLM_FUNC_QUALIFIER void operator() (T& e, T& t) { e /= t; } 
@@ -118,8 +118,8 @@ namespace detail
 		}
 
 	protected:
-		template <typename U>
-		GLM_FUNC_QUALIFIER void _apply_op(vecType<T, P> const& that, U op)
+		template<typename U>
+		GLM_FUNC_QUALIFIER void _apply_op(vec<N, T, P> const& that, U op)
 		{
 			// Make a copy of the data in this == &that.
 			// The copier should optimize out the copy in cases where the function is
@@ -133,8 +133,8 @@ namespace detail
 	};
 
 	// Specialization for swizzles containing duplicate elements.  These cannot be modified.
-	template <int N, typename T, precision P, template <typename, precision> class vecType, int E0, int E1, int E2, int E3>
-	struct _swizzle_base2<N, T, P, vecType, E0,E1,E2,E3, 1> : public _swizzle_base1<N, T, P, vecType, E0,E1,E2,E3, detail::is_aligned<P>::value>
+	template<int N, typename T, precision P, int E0, int E1, int E2, int E3>
+	struct _swizzle_base2<N, T, P, E0,E1,E2,E3, 1> : public _swizzle_base1<N, T, P, E0,E1,E2,E3, detail::is_aligned<P>::value>
 	{
 		struct Stub {};
 
@@ -147,40 +147,40 @@ namespace detail
 		}
 	};
 
-	template <int N, typename T, precision P, template <typename, precision> class vecType, int E0, int E1, int E2, int E3>
-	struct _swizzle : public _swizzle_base2<N, T, P, vecType, E0, E1, E2, E3, (E0 == E1 || E0 == E2 || E0 == E3 || E1 == E2 || E1 == E3 || E2 == E3)>
+	template<int N, typename T, precision P, int E0, int E1, int E2, int E3>
+	struct _swizzle : public _swizzle_base2<N, T, P, E0, E1, E2, E3, (E0 == E1 || E0 == E2 || E0 == E3 || E1 == E2 || E1 == E3 || E2 == E3)>
 	{
-		typedef _swizzle_base2<N, T, P, vecType, E0, E1, E2, E3, (E0 == E1 || E0 == E2 || E0 == E3 || E1 == E2 || E1 == E3 || E2 == E3)> base_type;
+		typedef _swizzle_base2<N, T, P, E0, E1, E2, E3, (E0 == E1 || E0 == E2 || E0 == E3 || E1 == E2 || E1 == E3 || E2 == E3)> base_type;
 
 		using base_type::operator=;
 
-		GLM_FUNC_QUALIFIER operator vecType<T, P> () const { return (*this)(); }
+		GLM_FUNC_QUALIFIER operator vec<N, T, P> () const { return (*this)(); }
 	};
 
 //
 // To prevent the C++ syntax from getting entirely overwhelming, define some alias macros
 //
-#define _GLM_SWIZZLE_TEMPLATE1   template <int N, typename T, precision P, template <typename, precision> class vecType, int E0, int E1, int E2, int E3>
-#define _GLM_SWIZZLE_TEMPLATE2   template <int N, typename T, precision P, template <typename, precision> class vecType, int E0, int E1, int E2, int E3, int F0, int F1, int F2, int F3>
-#define _GLM_SWIZZLE_TYPE1       _swizzle<N, T, P, vecType, E0, E1, E2, E3>
-#define _GLM_SWIZZLE_TYPE2       _swizzle<N, T, P, vecType, F0, F1, F2, F3>
+#define _GLM_SWIZZLE_TEMPLATE1   template<int N, typename T, precision P, int E0, int E1, int E2, int E3>
+#define _GLM_SWIZZLE_TEMPLATE2   template<int N, typename T, precision P, int E0, int E1, int E2, int E3, int F0, int F1, int F2, int F3>
+#define _GLM_SWIZZLE_TYPE1       _swizzle<N, T, P, E0, E1, E2, E3>
+#define _GLM_SWIZZLE_TYPE2       _swizzle<N, T, P, F0, F1, F2, F3>
 
 //
 // Wrapper for a binary operator (e.g. u.yy + v.zy)
 //
 #define _GLM_SWIZZLE_VECTOR_BINARY_OPERATOR_IMPLEMENTATION(OPERAND)                 \
 	_GLM_SWIZZLE_TEMPLATE2                                                          \
-	GLM_FUNC_QUALIFIER vecType<T, P> operator OPERAND ( const _GLM_SWIZZLE_TYPE1& a, const _GLM_SWIZZLE_TYPE2& b)  \
+	GLM_FUNC_QUALIFIER vec<N, T, P> operator OPERAND ( const _GLM_SWIZZLE_TYPE1& a, const _GLM_SWIZZLE_TYPE2& b)  \
 	{                                                                               \
 		return a() OPERAND b();                                                     \
 	}                                                                               \
 	_GLM_SWIZZLE_TEMPLATE1                                                          \
-	GLM_FUNC_QUALIFIER vecType<T, P> operator OPERAND ( const _GLM_SWIZZLE_TYPE1& a, const vecType<T, P>& b)                   \
+	GLM_FUNC_QUALIFIER vec<N, T, P> operator OPERAND ( const _GLM_SWIZZLE_TYPE1& a, const vec<N, T, P>& b)                   \
 	{                                                                               \
 		return a() OPERAND b;                                                       \
 	}                                                                               \
 	_GLM_SWIZZLE_TEMPLATE1                                                          \
-	GLM_FUNC_QUALIFIER vecType<T, P> operator OPERAND ( const vecType<T, P>& a, const _GLM_SWIZZLE_TYPE1& b)                   \
+	GLM_FUNC_QUALIFIER vec<N, T, P> operator OPERAND ( const vec<N, T, P>& a, const _GLM_SWIZZLE_TYPE1& b)                   \
 	{                                                                               \
 		return a OPERAND b();                                                       \
 	}
@@ -190,12 +190,12 @@ namespace detail
 //
 #define _GLM_SWIZZLE_SCALAR_BINARY_OPERATOR_IMPLEMENTATION(OPERAND)                 \
 	_GLM_SWIZZLE_TEMPLATE1                                                          \
-	GLM_FUNC_QUALIFIER vecType<T, P> operator OPERAND ( const _GLM_SWIZZLE_TYPE1& a, const T& b)                   \
+	GLM_FUNC_QUALIFIER vec<N, T, P> operator OPERAND ( const _GLM_SWIZZLE_TYPE1& a, const T& b)                   \
 	{                                                                               \
 		return a() OPERAND b;                                                       \
 	}                                                                               \
 	_GLM_SWIZZLE_TEMPLATE1                                                          \
-	GLM_FUNC_QUALIFIER vecType<T, P> operator OPERAND ( const T& a, const _GLM_SWIZZLE_TYPE1& b)                   \
+	GLM_FUNC_QUALIFIER vec<N, T, P> operator OPERAND ( const T& a, const _GLM_SWIZZLE_TYPE1& b)                   \
 	{                                                                               \
 		return a OPERAND b();                                                       \
 	}
@@ -297,501 +297,501 @@ namespace glm
 	//_GLM_SWIZZLE_FUNCTION_2_ARGS_SCALAR(vec_type, mix);
 }
 
-#define _GLM_SWIZZLE2_2_MEMBERS(T, P, V, E0,E1) \
-	struct { detail::_swizzle<2, T, P, V, 0,0,-1,-2> E0 ## E0; }; \
-	struct { detail::_swizzle<2, T, P, V, 0,1,-1,-2> E0 ## E1; }; \
-	struct { detail::_swizzle<2, T, P, V, 1,0,-1,-2> E1 ## E0; }; \
-	struct { detail::_swizzle<2, T, P, V, 1,1,-1,-2> E1 ## E1; }; 
+#define _GLM_SWIZZLE2_2_MEMBERS(T, P, E0,E1) \
+	struct { detail::_swizzle<2, T, P, 0,0,-1,-2> E0 ## E0; }; \
+	struct { detail::_swizzle<2, T, P, 0,1,-1,-2> E0 ## E1; }; \
+	struct { detail::_swizzle<2, T, P, 1,0,-1,-2> E1 ## E0; }; \
+	struct { detail::_swizzle<2, T, P, 1,1,-1,-2> E1 ## E1; }; 
 
-#define _GLM_SWIZZLE2_3_MEMBERS(T, P, V, E0,E1) \
-	struct { detail::_swizzle<3,T, P, V, 0,0,0,-1> E0 ## E0 ## E0; }; \
-	struct { detail::_swizzle<3,T, P, V, 0,0,1,-1> E0 ## E0 ## E1; }; \
-	struct { detail::_swizzle<3,T, P, V, 0,1,0,-1> E0 ## E1 ## E0; }; \
-	struct { detail::_swizzle<3,T, P, V, 0,1,1,-1> E0 ## E1 ## E1; }; \
-	struct { detail::_swizzle<3,T, P, V, 1,0,0,-1> E1 ## E0 ## E0; }; \
-	struct { detail::_swizzle<3,T, P, V, 1,0,1,-1> E1 ## E0 ## E1; }; \
-	struct { detail::_swizzle<3,T, P, V, 1,1,0,-1> E1 ## E1 ## E0; }; \
-	struct { detail::_swizzle<3,T, P, V, 1,1,1,-1> E1 ## E1 ## E1; };  
+#define _GLM_SWIZZLE2_3_MEMBERS(T, P, E0,E1) \
+	struct { detail::_swizzle<3,T, P, 0,0,0,-1> E0 ## E0 ## E0; }; \
+	struct { detail::_swizzle<3,T, P, 0,0,1,-1> E0 ## E0 ## E1; }; \
+	struct { detail::_swizzle<3,T, P, 0,1,0,-1> E0 ## E1 ## E0; }; \
+	struct { detail::_swizzle<3,T, P, 0,1,1,-1> E0 ## E1 ## E1; }; \
+	struct { detail::_swizzle<3,T, P, 1,0,0,-1> E1 ## E0 ## E0; }; \
+	struct { detail::_swizzle<3,T, P, 1,0,1,-1> E1 ## E0 ## E1; }; \
+	struct { detail::_swizzle<3,T, P, 1,1,0,-1> E1 ## E1 ## E0; }; \
+	struct { detail::_swizzle<3,T, P, 1,1,1,-1> E1 ## E1 ## E1; };  
 
-#define _GLM_SWIZZLE2_4_MEMBERS(T, P, V, E0,E1) \
-	struct { detail::_swizzle<4,T, P, V, 0,0,0,0> E0 ## E0 ## E0 ## E0; }; \
-	struct { detail::_swizzle<4,T, P, V, 0,0,0,1> E0 ## E0 ## E0 ## E1; }; \
-	struct { detail::_swizzle<4,T, P, V, 0,0,1,0> E0 ## E0 ## E1 ## E0; }; \
-	struct { detail::_swizzle<4,T, P, V, 0,0,1,1> E0 ## E0 ## E1 ## E1; }; \
-	struct { detail::_swizzle<4,T, P, V, 0,1,0,0> E0 ## E1 ## E0 ## E0; }; \
-	struct { detail::_swizzle<4,T, P, V, 0,1,0,1> E0 ## E1 ## E0 ## E1; }; \
-	struct { detail::_swizzle<4,T, P, V, 0,1,1,0> E0 ## E1 ## E1 ## E0; }; \
-	struct { detail::_swizzle<4,T, P, V, 0,1,1,1> E0 ## E1 ## E1 ## E1; }; \
-	struct { detail::_swizzle<4,T, P, V, 1,0,0,0> E1 ## E0 ## E0 ## E0; }; \
-	struct { detail::_swizzle<4,T, P, V, 1,0,0,1> E1 ## E0 ## E0 ## E1; }; \
-	struct { detail::_swizzle<4,T, P, V, 1,0,1,0> E1 ## E0 ## E1 ## E0; }; \
-	struct { detail::_swizzle<4,T, P, V, 1,0,1,1> E1 ## E0 ## E1 ## E1; }; \
-	struct { detail::_swizzle<4,T, P, V, 1,1,0,0> E1 ## E1 ## E0 ## E0; }; \
-	struct { detail::_swizzle<4,T, P, V, 1,1,0,1> E1 ## E1 ## E0 ## E1; }; \
-	struct { detail::_swizzle<4,T, P, V, 1,1,1,0> E1 ## E1 ## E1 ## E0; }; \
-	struct { detail::_swizzle<4,T, P, V, 1,1,1,1> E1 ## E1 ## E1 ## E1; };
+#define _GLM_SWIZZLE2_4_MEMBERS(T, P, E0,E1) \
+	struct { detail::_swizzle<4,T, P, 0,0,0,0> E0 ## E0 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4,T, P, 0,0,0,1> E0 ## E0 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4,T, P, 0,0,1,0> E0 ## E0 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4,T, P, 0,0,1,1> E0 ## E0 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4,T, P, 0,1,0,0> E0 ## E1 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4,T, P, 0,1,0,1> E0 ## E1 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4,T, P, 0,1,1,0> E0 ## E1 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4,T, P, 0,1,1,1> E0 ## E1 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4,T, P, 1,0,0,0> E1 ## E0 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4,T, P, 1,0,0,1> E1 ## E0 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4,T, P, 1,0,1,0> E1 ## E0 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4,T, P, 1,0,1,1> E1 ## E0 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4,T, P, 1,1,0,0> E1 ## E1 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4,T, P, 1,1,0,1> E1 ## E1 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4,T, P, 1,1,1,0> E1 ## E1 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4,T, P, 1,1,1,1> E1 ## E1 ## E1 ## E1; };
 
-#define _GLM_SWIZZLE3_2_MEMBERS(T, P, V, E0,E1,E2) \
-	struct { detail::_swizzle<2,T, P, V, 0,0,-1,-2> E0 ## E0; }; \
-	struct { detail::_swizzle<2,T, P, V, 0,1,-1,-2> E0 ## E1; }; \
-	struct { detail::_swizzle<2,T, P, V, 0,2,-1,-2> E0 ## E2; }; \
-	struct { detail::_swizzle<2,T, P, V, 1,0,-1,-2> E1 ## E0; }; \
-	struct { detail::_swizzle<2,T, P, V, 1,1,-1,-2> E1 ## E1; }; \
-	struct { detail::_swizzle<2,T, P, V, 1,2,-1,-2> E1 ## E2; }; \
-	struct { detail::_swizzle<2,T, P, V, 2,0,-1,-2> E2 ## E0; }; \
-	struct { detail::_swizzle<2,T, P, V, 2,1,-1,-2> E2 ## E1; }; \
-	struct { detail::_swizzle<2,T, P, V, 2,2,-1,-2> E2 ## E2; };
+#define _GLM_SWIZZLE3_2_MEMBERS(T, P, E0,E1,E2) \
+	struct { detail::_swizzle<2,T, P, 0,0,-1,-2> E0 ## E0; }; \
+	struct { detail::_swizzle<2,T, P, 0,1,-1,-2> E0 ## E1; }; \
+	struct { detail::_swizzle<2,T, P, 0,2,-1,-2> E0 ## E2; }; \
+	struct { detail::_swizzle<2,T, P, 1,0,-1,-2> E1 ## E0; }; \
+	struct { detail::_swizzle<2,T, P, 1,1,-1,-2> E1 ## E1; }; \
+	struct { detail::_swizzle<2,T, P, 1,2,-1,-2> E1 ## E2; }; \
+	struct { detail::_swizzle<2,T, P, 2,0,-1,-2> E2 ## E0; }; \
+	struct { detail::_swizzle<2,T, P, 2,1,-1,-2> E2 ## E1; }; \
+	struct { detail::_swizzle<2,T, P, 2,2,-1,-2> E2 ## E2; };
 
-#define _GLM_SWIZZLE3_3_MEMBERS(T, P, V ,E0,E1,E2) \
-	struct { detail::_swizzle<3, T, P, V, 0,0,0,-1> E0 ## E0 ## E0; }; \
-	struct { detail::_swizzle<3, T, P, V, 0,0,1,-1> E0 ## E0 ## E1; }; \
-	struct { detail::_swizzle<3, T, P, V, 0,0,2,-1> E0 ## E0 ## E2; }; \
-	struct { detail::_swizzle<3, T, P, V, 0,1,0,-1> E0 ## E1 ## E0; }; \
-	struct { detail::_swizzle<3, T, P, V, 0,1,1,-1> E0 ## E1 ## E1; }; \
-	struct { detail::_swizzle<3, T, P, V, 0,1,2,-1> E0 ## E1 ## E2; }; \
-	struct { detail::_swizzle<3, T, P, V, 0,2,0,-1> E0 ## E2 ## E0; }; \
-	struct { detail::_swizzle<3, T, P, V, 0,2,1,-1> E0 ## E2 ## E1; }; \
-	struct { detail::_swizzle<3, T, P, V, 0,2,2,-1> E0 ## E2 ## E2; }; \
-	struct { detail::_swizzle<3, T, P, V, 1,0,0,-1> E1 ## E0 ## E0; }; \
-	struct { detail::_swizzle<3, T, P, V, 1,0,1,-1> E1 ## E0 ## E1; }; \
-	struct { detail::_swizzle<3, T, P, V, 1,0,2,-1> E1 ## E0 ## E2; }; \
-	struct { detail::_swizzle<3, T, P, V, 1,1,0,-1> E1 ## E1 ## E0; }; \
-	struct { detail::_swizzle<3, T, P, V, 1,1,1,-1> E1 ## E1 ## E1; }; \
-	struct { detail::_swizzle<3, T, P, V, 1,1,2,-1> E1 ## E1 ## E2; }; \
-	struct { detail::_swizzle<3, T, P, V, 1,2,0,-1> E1 ## E2 ## E0; }; \
-	struct { detail::_swizzle<3, T, P, V, 1,2,1,-1> E1 ## E2 ## E1; }; \
-	struct { detail::_swizzle<3, T, P, V, 1,2,2,-1> E1 ## E2 ## E2; }; \
-	struct { detail::_swizzle<3, T, P, V, 2,0,0,-1> E2 ## E0 ## E0; }; \
-	struct { detail::_swizzle<3, T, P, V, 2,0,1,-1> E2 ## E0 ## E1; }; \
-	struct { detail::_swizzle<3, T, P, V, 2,0,2,-1> E2 ## E0 ## E2; }; \
-	struct { detail::_swizzle<3, T, P, V, 2,1,0,-1> E2 ## E1 ## E0; }; \
-	struct { detail::_swizzle<3, T, P, V, 2,1,1,-1> E2 ## E1 ## E1; }; \
-	struct { detail::_swizzle<3, T, P, V, 2,1,2,-1> E2 ## E1 ## E2; }; \
-	struct { detail::_swizzle<3, T, P, V, 2,2,0,-1> E2 ## E2 ## E0; }; \
-	struct { detail::_swizzle<3, T, P, V, 2,2,1,-1> E2 ## E2 ## E1; }; \
-	struct { detail::_swizzle<3, T, P, V, 2,2,2,-1> E2 ## E2 ## E2; };
+#define _GLM_SWIZZLE3_3_MEMBERS(T, P ,E0,E1,E2) \
+	struct { detail::_swizzle<3, T, P, 0,0,0,-1> E0 ## E0 ## E0; }; \
+	struct { detail::_swizzle<3, T, P, 0,0,1,-1> E0 ## E0 ## E1; }; \
+	struct { detail::_swizzle<3, T, P, 0,0,2,-1> E0 ## E0 ## E2; }; \
+	struct { detail::_swizzle<3, T, P, 0,1,0,-1> E0 ## E1 ## E0; }; \
+	struct { detail::_swizzle<3, T, P, 0,1,1,-1> E0 ## E1 ## E1; }; \
+	struct { detail::_swizzle<3, T, P, 0,1,2,-1> E0 ## E1 ## E2; }; \
+	struct { detail::_swizzle<3, T, P, 0,2,0,-1> E0 ## E2 ## E0; }; \
+	struct { detail::_swizzle<3, T, P, 0,2,1,-1> E0 ## E2 ## E1; }; \
+	struct { detail::_swizzle<3, T, P, 0,2,2,-1> E0 ## E2 ## E2; }; \
+	struct { detail::_swizzle<3, T, P, 1,0,0,-1> E1 ## E0 ## E0; }; \
+	struct { detail::_swizzle<3, T, P, 1,0,1,-1> E1 ## E0 ## E1; }; \
+	struct { detail::_swizzle<3, T, P, 1,0,2,-1> E1 ## E0 ## E2; }; \
+	struct { detail::_swizzle<3, T, P, 1,1,0,-1> E1 ## E1 ## E0; }; \
+	struct { detail::_swizzle<3, T, P, 1,1,1,-1> E1 ## E1 ## E1; }; \
+	struct { detail::_swizzle<3, T, P, 1,1,2,-1> E1 ## E1 ## E2; }; \
+	struct { detail::_swizzle<3, T, P, 1,2,0,-1> E1 ## E2 ## E0; }; \
+	struct { detail::_swizzle<3, T, P, 1,2,1,-1> E1 ## E2 ## E1; }; \
+	struct { detail::_swizzle<3, T, P, 1,2,2,-1> E1 ## E2 ## E2; }; \
+	struct { detail::_swizzle<3, T, P, 2,0,0,-1> E2 ## E0 ## E0; }; \
+	struct { detail::_swizzle<3, T, P, 2,0,1,-1> E2 ## E0 ## E1; }; \
+	struct { detail::_swizzle<3, T, P, 2,0,2,-1> E2 ## E0 ## E2; }; \
+	struct { detail::_swizzle<3, T, P, 2,1,0,-1> E2 ## E1 ## E0; }; \
+	struct { detail::_swizzle<3, T, P, 2,1,1,-1> E2 ## E1 ## E1; }; \
+	struct { detail::_swizzle<3, T, P, 2,1,2,-1> E2 ## E1 ## E2; }; \
+	struct { detail::_swizzle<3, T, P, 2,2,0,-1> E2 ## E2 ## E0; }; \
+	struct { detail::_swizzle<3, T, P, 2,2,1,-1> E2 ## E2 ## E1; }; \
+	struct { detail::_swizzle<3, T, P, 2,2,2,-1> E2 ## E2 ## E2; };
 
-#define _GLM_SWIZZLE3_4_MEMBERS(T, P, V, E0,E1,E2) \
-	struct { detail::_swizzle<4,T, P, V, 0,0,0,0> E0 ## E0 ## E0 ## E0; }; \
-	struct { detail::_swizzle<4,T, P, V, 0,0,0,1> E0 ## E0 ## E0 ## E1; }; \
-	struct { detail::_swizzle<4,T, P, V, 0,0,0,2> E0 ## E0 ## E0 ## E2; }; \
-	struct { detail::_swizzle<4,T, P, V, 0,0,1,0> E0 ## E0 ## E1 ## E0; }; \
-	struct { detail::_swizzle<4,T, P, V, 0,0,1,1> E0 ## E0 ## E1 ## E1; }; \
-	struct { detail::_swizzle<4,T, P, V, 0,0,1,2> E0 ## E0 ## E1 ## E2; }; \
-	struct { detail::_swizzle<4,T, P, V, 0,0,2,0> E0 ## E0 ## E2 ## E0; }; \
-	struct { detail::_swizzle<4,T, P, V, 0,0,2,1> E0 ## E0 ## E2 ## E1; }; \
-	struct { detail::_swizzle<4,T, P, V, 0,0,2,2> E0 ## E0 ## E2 ## E2; }; \
-	struct { detail::_swizzle<4,T, P, V, 0,1,0,0> E0 ## E1 ## E0 ## E0; }; \
-	struct { detail::_swizzle<4,T, P, V, 0,1,0,1> E0 ## E1 ## E0 ## E1; }; \
-	struct { detail::_swizzle<4,T, P, V, 0,1,0,2> E0 ## E1 ## E0 ## E2; }; \
-	struct { detail::_swizzle<4,T, P, V, 0,1,1,0> E0 ## E1 ## E1 ## E0; }; \
-	struct { detail::_swizzle<4,T, P, V, 0,1,1,1> E0 ## E1 ## E1 ## E1; }; \
-	struct { detail::_swizzle<4,T, P, V, 0,1,1,2> E0 ## E1 ## E1 ## E2; }; \
-	struct { detail::_swizzle<4,T, P, V, 0,1,2,0> E0 ## E1 ## E2 ## E0; }; \
-	struct { detail::_swizzle<4,T, P, V, 0,1,2,1> E0 ## E1 ## E2 ## E1; }; \
-	struct { detail::_swizzle<4,T, P, V, 0,1,2,2> E0 ## E1 ## E2 ## E2; }; \
-	struct { detail::_swizzle<4,T, P, V, 0,2,0,0> E0 ## E2 ## E0 ## E0; }; \
-	struct { detail::_swizzle<4,T, P, V, 0,2,0,1> E0 ## E2 ## E0 ## E1; }; \
-	struct { detail::_swizzle<4,T, P, V, 0,2,0,2> E0 ## E2 ## E0 ## E2; }; \
-	struct { detail::_swizzle<4,T, P, V, 0,2,1,0> E0 ## E2 ## E1 ## E0; }; \
-	struct { detail::_swizzle<4,T, P, V, 0,2,1,1> E0 ## E2 ## E1 ## E1; }; \
-	struct { detail::_swizzle<4,T, P, V, 0,2,1,2> E0 ## E2 ## E1 ## E2; }; \
-	struct { detail::_swizzle<4,T, P, V, 0,2,2,0> E0 ## E2 ## E2 ## E0; }; \
-	struct { detail::_swizzle<4,T, P, V, 0,2,2,1> E0 ## E2 ## E2 ## E1; }; \
-	struct { detail::_swizzle<4,T, P, V, 0,2,2,2> E0 ## E2 ## E2 ## E2; }; \
-	struct { detail::_swizzle<4,T, P, V, 1,0,0,0> E1 ## E0 ## E0 ## E0; }; \
-	struct { detail::_swizzle<4,T, P, V, 1,0,0,1> E1 ## E0 ## E0 ## E1; }; \
-	struct { detail::_swizzle<4,T, P, V, 1,0,0,2> E1 ## E0 ## E0 ## E2; }; \
-	struct { detail::_swizzle<4,T, P, V, 1,0,1,0> E1 ## E0 ## E1 ## E0; }; \
-	struct { detail::_swizzle<4,T, P, V, 1,0,1,1> E1 ## E0 ## E1 ## E1; }; \
-	struct { detail::_swizzle<4,T, P, V, 1,0,1,2> E1 ## E0 ## E1 ## E2; }; \
-	struct { detail::_swizzle<4,T, P, V, 1,0,2,0> E1 ## E0 ## E2 ## E0; }; \
-	struct { detail::_swizzle<4,T, P, V, 1,0,2,1> E1 ## E0 ## E2 ## E1; }; \
-	struct { detail::_swizzle<4,T, P, V, 1,0,2,2> E1 ## E0 ## E2 ## E2; }; \
-	struct { detail::_swizzle<4,T, P, V, 1,1,0,0> E1 ## E1 ## E0 ## E0; }; \
-	struct { detail::_swizzle<4,T, P, V, 1,1,0,1> E1 ## E1 ## E0 ## E1; }; \
-	struct { detail::_swizzle<4,T, P, V, 1,1,0,2> E1 ## E1 ## E0 ## E2; }; \
-	struct { detail::_swizzle<4,T, P, V, 1,1,1,0> E1 ## E1 ## E1 ## E0; }; \
-	struct { detail::_swizzle<4,T, P, V, 1,1,1,1> E1 ## E1 ## E1 ## E1; }; \
-	struct { detail::_swizzle<4,T, P, V, 1,1,1,2> E1 ## E1 ## E1 ## E2; }; \
-	struct { detail::_swizzle<4,T, P, V, 1,1,2,0> E1 ## E1 ## E2 ## E0; }; \
-	struct { detail::_swizzle<4,T, P, V, 1,1,2,1> E1 ## E1 ## E2 ## E1; }; \
-	struct { detail::_swizzle<4,T, P, V, 1,1,2,2> E1 ## E1 ## E2 ## E2; }; \
-	struct { detail::_swizzle<4,T, P, V, 1,2,0,0> E1 ## E2 ## E0 ## E0; }; \
-	struct { detail::_swizzle<4,T, P, V, 1,2,0,1> E1 ## E2 ## E0 ## E1; }; \
-	struct { detail::_swizzle<4,T, P, V, 1,2,0,2> E1 ## E2 ## E0 ## E2; }; \
-	struct { detail::_swizzle<4,T, P, V, 1,2,1,0> E1 ## E2 ## E1 ## E0; }; \
-	struct { detail::_swizzle<4,T, P, V, 1,2,1,1> E1 ## E2 ## E1 ## E1; }; \
-	struct { detail::_swizzle<4,T, P, V, 1,2,1,2> E1 ## E2 ## E1 ## E2; }; \
-	struct { detail::_swizzle<4,T, P, V, 1,2,2,0> E1 ## E2 ## E2 ## E0; }; \
-	struct { detail::_swizzle<4,T, P, V, 1,2,2,1> E1 ## E2 ## E2 ## E1; }; \
-	struct { detail::_swizzle<4,T, P, V, 1,2,2,2> E1 ## E2 ## E2 ## E2; }; \
-	struct { detail::_swizzle<4,T, P, V, 2,0,0,0> E2 ## E0 ## E0 ## E0; }; \
-	struct { detail::_swizzle<4,T, P, V, 2,0,0,1> E2 ## E0 ## E0 ## E1; }; \
-	struct { detail::_swizzle<4,T, P, V, 2,0,0,2> E2 ## E0 ## E0 ## E2; }; \
-	struct { detail::_swizzle<4,T, P, V, 2,0,1,0> E2 ## E0 ## E1 ## E0; }; \
-	struct { detail::_swizzle<4,T, P, V, 2,0,1,1> E2 ## E0 ## E1 ## E1; }; \
-	struct { detail::_swizzle<4,T, P, V, 2,0,1,2> E2 ## E0 ## E1 ## E2; }; \
-	struct { detail::_swizzle<4,T, P, V, 2,0,2,0> E2 ## E0 ## E2 ## E0; }; \
-	struct { detail::_swizzle<4,T, P, V, 2,0,2,1> E2 ## E0 ## E2 ## E1; }; \
-	struct { detail::_swizzle<4,T, P, V, 2,0,2,2> E2 ## E0 ## E2 ## E2; }; \
-	struct { detail::_swizzle<4,T, P, V, 2,1,0,0> E2 ## E1 ## E0 ## E0; }; \
-	struct { detail::_swizzle<4,T, P, V, 2,1,0,1> E2 ## E1 ## E0 ## E1; }; \
-	struct { detail::_swizzle<4,T, P, V, 2,1,0,2> E2 ## E1 ## E0 ## E2; }; \
-	struct { detail::_swizzle<4,T, P, V, 2,1,1,0> E2 ## E1 ## E1 ## E0; }; \
-	struct { detail::_swizzle<4,T, P, V, 2,1,1,1> E2 ## E1 ## E1 ## E1; }; \
-	struct { detail::_swizzle<4,T, P, V, 2,1,1,2> E2 ## E1 ## E1 ## E2; }; \
-	struct { detail::_swizzle<4,T, P, V, 2,1,2,0> E2 ## E1 ## E2 ## E0; }; \
-	struct { detail::_swizzle<4,T, P, V, 2,1,2,1> E2 ## E1 ## E2 ## E1; }; \
-	struct { detail::_swizzle<4,T, P, V, 2,1,2,2> E2 ## E1 ## E2 ## E2; }; \
-	struct { detail::_swizzle<4,T, P, V, 2,2,0,0> E2 ## E2 ## E0 ## E0; }; \
-	struct { detail::_swizzle<4,T, P, V, 2,2,0,1> E2 ## E2 ## E0 ## E1; }; \
-	struct { detail::_swizzle<4,T, P, V, 2,2,0,2> E2 ## E2 ## E0 ## E2; }; \
-	struct { detail::_swizzle<4,T, P, V, 2,2,1,0> E2 ## E2 ## E1 ## E0; }; \
-	struct { detail::_swizzle<4,T, P, V, 2,2,1,1> E2 ## E2 ## E1 ## E1; }; \
-	struct { detail::_swizzle<4,T, P, V, 2,2,1,2> E2 ## E2 ## E1 ## E2; }; \
-	struct { detail::_swizzle<4,T, P, V, 2,2,2,0> E2 ## E2 ## E2 ## E0; }; \
-	struct { detail::_swizzle<4,T, P, V, 2,2,2,1> E2 ## E2 ## E2 ## E1; }; \
-	struct { detail::_swizzle<4,T, P, V, 2,2,2,2> E2 ## E2 ## E2 ## E2; }; 
+#define _GLM_SWIZZLE3_4_MEMBERS(T, P, E0,E1,E2) \
+	struct { detail::_swizzle<4,T, P, 0,0,0,0> E0 ## E0 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4,T, P, 0,0,0,1> E0 ## E0 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4,T, P, 0,0,0,2> E0 ## E0 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4,T, P, 0,0,1,0> E0 ## E0 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4,T, P, 0,0,1,1> E0 ## E0 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4,T, P, 0,0,1,2> E0 ## E0 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4,T, P, 0,0,2,0> E0 ## E0 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4,T, P, 0,0,2,1> E0 ## E0 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4,T, P, 0,0,2,2> E0 ## E0 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4,T, P, 0,1,0,0> E0 ## E1 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4,T, P, 0,1,0,1> E0 ## E1 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4,T, P, 0,1,0,2> E0 ## E1 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4,T, P, 0,1,1,0> E0 ## E1 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4,T, P, 0,1,1,1> E0 ## E1 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4,T, P, 0,1,1,2> E0 ## E1 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4,T, P, 0,1,2,0> E0 ## E1 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4,T, P, 0,1,2,1> E0 ## E1 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4,T, P, 0,1,2,2> E0 ## E1 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4,T, P, 0,2,0,0> E0 ## E2 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4,T, P, 0,2,0,1> E0 ## E2 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4,T, P, 0,2,0,2> E0 ## E2 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4,T, P, 0,2,1,0> E0 ## E2 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4,T, P, 0,2,1,1> E0 ## E2 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4,T, P, 0,2,1,2> E0 ## E2 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4,T, P, 0,2,2,0> E0 ## E2 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4,T, P, 0,2,2,1> E0 ## E2 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4,T, P, 0,2,2,2> E0 ## E2 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4,T, P, 1,0,0,0> E1 ## E0 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4,T, P, 1,0,0,1> E1 ## E0 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4,T, P, 1,0,0,2> E1 ## E0 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4,T, P, 1,0,1,0> E1 ## E0 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4,T, P, 1,0,1,1> E1 ## E0 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4,T, P, 1,0,1,2> E1 ## E0 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4,T, P, 1,0,2,0> E1 ## E0 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4,T, P, 1,0,2,1> E1 ## E0 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4,T, P, 1,0,2,2> E1 ## E0 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4,T, P, 1,1,0,0> E1 ## E1 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4,T, P, 1,1,0,1> E1 ## E1 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4,T, P, 1,1,0,2> E1 ## E1 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4,T, P, 1,1,1,0> E1 ## E1 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4,T, P, 1,1,1,1> E1 ## E1 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4,T, P, 1,1,1,2> E1 ## E1 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4,T, P, 1,1,2,0> E1 ## E1 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4,T, P, 1,1,2,1> E1 ## E1 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4,T, P, 1,1,2,2> E1 ## E1 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4,T, P, 1,2,0,0> E1 ## E2 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4,T, P, 1,2,0,1> E1 ## E2 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4,T, P, 1,2,0,2> E1 ## E2 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4,T, P, 1,2,1,0> E1 ## E2 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4,T, P, 1,2,1,1> E1 ## E2 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4,T, P, 1,2,1,2> E1 ## E2 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4,T, P, 1,2,2,0> E1 ## E2 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4,T, P, 1,2,2,1> E1 ## E2 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4,T, P, 1,2,2,2> E1 ## E2 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4,T, P, 2,0,0,0> E2 ## E0 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4,T, P, 2,0,0,1> E2 ## E0 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4,T, P, 2,0,0,2> E2 ## E0 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4,T, P, 2,0,1,0> E2 ## E0 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4,T, P, 2,0,1,1> E2 ## E0 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4,T, P, 2,0,1,2> E2 ## E0 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4,T, P, 2,0,2,0> E2 ## E0 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4,T, P, 2,0,2,1> E2 ## E0 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4,T, P, 2,0,2,2> E2 ## E0 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4,T, P, 2,1,0,0> E2 ## E1 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4,T, P, 2,1,0,1> E2 ## E1 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4,T, P, 2,1,0,2> E2 ## E1 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4,T, P, 2,1,1,0> E2 ## E1 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4,T, P, 2,1,1,1> E2 ## E1 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4,T, P, 2,1,1,2> E2 ## E1 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4,T, P, 2,1,2,0> E2 ## E1 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4,T, P, 2,1,2,1> E2 ## E1 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4,T, P, 2,1,2,2> E2 ## E1 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4,T, P, 2,2,0,0> E2 ## E2 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4,T, P, 2,2,0,1> E2 ## E2 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4,T, P, 2,2,0,2> E2 ## E2 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4,T, P, 2,2,1,0> E2 ## E2 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4,T, P, 2,2,1,1> E2 ## E2 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4,T, P, 2,2,1,2> E2 ## E2 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4,T, P, 2,2,2,0> E2 ## E2 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4,T, P, 2,2,2,1> E2 ## E2 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4,T, P, 2,2,2,2> E2 ## E2 ## E2 ## E2; }; 
 
-#define _GLM_SWIZZLE4_2_MEMBERS(T, P, V, E0,E1,E2,E3) \
-	struct { detail::_swizzle<2,T, P, V, 0,0,-1,-2> E0 ## E0; }; \
-	struct { detail::_swizzle<2,T, P, V, 0,1,-1,-2> E0 ## E1; }; \
-	struct { detail::_swizzle<2,T, P, V, 0,2,-1,-2> E0 ## E2; }; \
-	struct { detail::_swizzle<2,T, P, V, 0,3,-1,-2> E0 ## E3; }; \
-	struct { detail::_swizzle<2,T, P, V, 1,0,-1,-2> E1 ## E0; }; \
-	struct { detail::_swizzle<2,T, P, V, 1,1,-1,-2> E1 ## E1; }; \
-	struct { detail::_swizzle<2,T, P, V, 1,2,-1,-2> E1 ## E2; }; \
-	struct { detail::_swizzle<2,T, P, V, 1,3,-1,-2> E1 ## E3; }; \
-	struct { detail::_swizzle<2,T, P, V, 2,0,-1,-2> E2 ## E0; }; \
-	struct { detail::_swizzle<2,T, P, V, 2,1,-1,-2> E2 ## E1; }; \
-	struct { detail::_swizzle<2,T, P, V, 2,2,-1,-2> E2 ## E2; }; \
-	struct { detail::_swizzle<2,T, P, V, 2,3,-1,-2> E2 ## E3; }; \
-	struct { detail::_swizzle<2,T, P, V, 3,0,-1,-2> E3 ## E0; }; \
-	struct { detail::_swizzle<2,T, P, V, 3,1,-1,-2> E3 ## E1; }; \
-	struct { detail::_swizzle<2,T, P, V, 3,2,-1,-2> E3 ## E2; }; \
-	struct { detail::_swizzle<2,T, P, V, 3,3,-1,-2> E3 ## E3; }; 
+#define _GLM_SWIZZLE4_2_MEMBERS(T, P, E0,E1,E2,E3) \
+	struct { detail::_swizzle<2,T, P, 0,0,-1,-2> E0 ## E0; }; \
+	struct { detail::_swizzle<2,T, P, 0,1,-1,-2> E0 ## E1; }; \
+	struct { detail::_swizzle<2,T, P, 0,2,-1,-2> E0 ## E2; }; \
+	struct { detail::_swizzle<2,T, P, 0,3,-1,-2> E0 ## E3; }; \
+	struct { detail::_swizzle<2,T, P, 1,0,-1,-2> E1 ## E0; }; \
+	struct { detail::_swizzle<2,T, P, 1,1,-1,-2> E1 ## E1; }; \
+	struct { detail::_swizzle<2,T, P, 1,2,-1,-2> E1 ## E2; }; \
+	struct { detail::_swizzle<2,T, P, 1,3,-1,-2> E1 ## E3; }; \
+	struct { detail::_swizzle<2,T, P, 2,0,-1,-2> E2 ## E0; }; \
+	struct { detail::_swizzle<2,T, P, 2,1,-1,-2> E2 ## E1; }; \
+	struct { detail::_swizzle<2,T, P, 2,2,-1,-2> E2 ## E2; }; \
+	struct { detail::_swizzle<2,T, P, 2,3,-1,-2> E2 ## E3; }; \
+	struct { detail::_swizzle<2,T, P, 3,0,-1,-2> E3 ## E0; }; \
+	struct { detail::_swizzle<2,T, P, 3,1,-1,-2> E3 ## E1; }; \
+	struct { detail::_swizzle<2,T, P, 3,2,-1,-2> E3 ## E2; }; \
+	struct { detail::_swizzle<2,T, P, 3,3,-1,-2> E3 ## E3; }; 
 
-#define _GLM_SWIZZLE4_3_MEMBERS(T, P, V, E0,E1,E2,E3) \
-	struct { detail::_swizzle<3, T, P, V, 0,0,0,-1> E0 ## E0 ## E0; }; \
-	struct { detail::_swizzle<3, T, P, V, 0,0,1,-1> E0 ## E0 ## E1; }; \
-	struct { detail::_swizzle<3, T, P, V, 0,0,2,-1> E0 ## E0 ## E2; }; \
-	struct { detail::_swizzle<3, T, P, V, 0,0,3,-1> E0 ## E0 ## E3; }; \
-	struct { detail::_swizzle<3, T, P, V, 0,1,0,-1> E0 ## E1 ## E0; }; \
-	struct { detail::_swizzle<3, T, P, V, 0,1,1,-1> E0 ## E1 ## E1; }; \
-	struct { detail::_swizzle<3, T, P, V, 0,1,2,-1> E0 ## E1 ## E2; }; \
-	struct { detail::_swizzle<3, T, P, V, 0,1,3,-1> E0 ## E1 ## E3; }; \
-	struct { detail::_swizzle<3, T, P, V, 0,2,0,-1> E0 ## E2 ## E0; }; \
-	struct { detail::_swizzle<3, T, P, V, 0,2,1,-1> E0 ## E2 ## E1; }; \
-	struct { detail::_swizzle<3, T, P, V, 0,2,2,-1> E0 ## E2 ## E2; }; \
-	struct { detail::_swizzle<3, T, P, V, 0,2,3,-1> E0 ## E2 ## E3; }; \
-	struct { detail::_swizzle<3, T, P, V, 0,3,0,-1> E0 ## E3 ## E0; }; \
-	struct { detail::_swizzle<3, T, P, V, 0,3,1,-1> E0 ## E3 ## E1; }; \
-	struct { detail::_swizzle<3, T, P, V, 0,3,2,-1> E0 ## E3 ## E2; }; \
-	struct { detail::_swizzle<3, T, P, V, 0,3,3,-1> E0 ## E3 ## E3; }; \
-	struct { detail::_swizzle<3, T, P, V, 1,0,0,-1> E1 ## E0 ## E0; }; \
-	struct { detail::_swizzle<3, T, P, V, 1,0,1,-1> E1 ## E0 ## E1; }; \
-	struct { detail::_swizzle<3, T, P, V, 1,0,2,-1> E1 ## E0 ## E2; }; \
-	struct { detail::_swizzle<3, T, P, V, 1,0,3,-1> E1 ## E0 ## E3; }; \
-	struct { detail::_swizzle<3, T, P, V, 1,1,0,-1> E1 ## E1 ## E0; }; \
-	struct { detail::_swizzle<3, T, P, V, 1,1,1,-1> E1 ## E1 ## E1; }; \
-	struct { detail::_swizzle<3, T, P, V, 1,1,2,-1> E1 ## E1 ## E2; }; \
-	struct { detail::_swizzle<3, T, P, V, 1,1,3,-1> E1 ## E1 ## E3; }; \
-	struct { detail::_swizzle<3, T, P, V, 1,2,0,-1> E1 ## E2 ## E0; }; \
-	struct { detail::_swizzle<3, T, P, V, 1,2,1,-1> E1 ## E2 ## E1; }; \
-	struct { detail::_swizzle<3, T, P, V, 1,2,2,-1> E1 ## E2 ## E2; }; \
-	struct { detail::_swizzle<3, T, P, V, 1,2,3,-1> E1 ## E2 ## E3; }; \
-	struct { detail::_swizzle<3, T, P, V, 1,3,0,-1> E1 ## E3 ## E0; }; \
-	struct { detail::_swizzle<3, T, P, V, 1,3,1,-1> E1 ## E3 ## E1; }; \
-	struct { detail::_swizzle<3, T, P, V, 1,3,2,-1> E1 ## E3 ## E2; }; \
-	struct { detail::_swizzle<3, T, P, V, 1,3,3,-1> E1 ## E3 ## E3; }; \
-	struct { detail::_swizzle<3, T, P, V, 2,0,0,-1> E2 ## E0 ## E0; }; \
-	struct { detail::_swizzle<3, T, P, V, 2,0,1,-1> E2 ## E0 ## E1; }; \
-	struct { detail::_swizzle<3, T, P, V, 2,0,2,-1> E2 ## E0 ## E2; }; \
-	struct { detail::_swizzle<3, T, P, V, 2,0,3,-1> E2 ## E0 ## E3; }; \
-	struct { detail::_swizzle<3, T, P, V, 2,1,0,-1> E2 ## E1 ## E0; }; \
-	struct { detail::_swizzle<3, T, P, V, 2,1,1,-1> E2 ## E1 ## E1; }; \
-	struct { detail::_swizzle<3, T, P, V, 2,1,2,-1> E2 ## E1 ## E2; }; \
-	struct { detail::_swizzle<3, T, P, V, 2,1,3,-1> E2 ## E1 ## E3; }; \
-	struct { detail::_swizzle<3, T, P, V, 2,2,0,-1> E2 ## E2 ## E0; }; \
-	struct { detail::_swizzle<3, T, P, V, 2,2,1,-1> E2 ## E2 ## E1; }; \
-	struct { detail::_swizzle<3, T, P, V, 2,2,2,-1> E2 ## E2 ## E2; }; \
-	struct { detail::_swizzle<3, T, P, V, 2,2,3,-1> E2 ## E2 ## E3; }; \
-	struct { detail::_swizzle<3, T, P, V, 2,3,0,-1> E2 ## E3 ## E0; }; \
-	struct { detail::_swizzle<3, T, P, V, 2,3,1,-1> E2 ## E3 ## E1; }; \
-	struct { detail::_swizzle<3, T, P, V, 2,3,2,-1> E2 ## E3 ## E2; }; \
-	struct { detail::_swizzle<3, T, P, V, 2,3,3,-1> E2 ## E3 ## E3; }; \
-	struct { detail::_swizzle<3, T, P, V, 3,0,0,-1> E3 ## E0 ## E0; }; \
-	struct { detail::_swizzle<3, T, P, V, 3,0,1,-1> E3 ## E0 ## E1; }; \
-	struct { detail::_swizzle<3, T, P, V, 3,0,2,-1> E3 ## E0 ## E2; }; \
-	struct { detail::_swizzle<3, T, P, V, 3,0,3,-1> E3 ## E0 ## E3; }; \
-	struct { detail::_swizzle<3, T, P, V, 3,1,0,-1> E3 ## E1 ## E0; }; \
-	struct { detail::_swizzle<3, T, P, V, 3,1,1,-1> E3 ## E1 ## E1; }; \
-	struct { detail::_swizzle<3, T, P, V, 3,1,2,-1> E3 ## E1 ## E2; }; \
-	struct { detail::_swizzle<3, T, P, V, 3,1,3,-1> E3 ## E1 ## E3; }; \
-	struct { detail::_swizzle<3, T, P, V, 3,2,0,-1> E3 ## E2 ## E0; }; \
-	struct { detail::_swizzle<3, T, P, V, 3,2,1,-1> E3 ## E2 ## E1; }; \
-	struct { detail::_swizzle<3, T, P, V, 3,2,2,-1> E3 ## E2 ## E2; }; \
-	struct { detail::_swizzle<3, T, P, V, 3,2,3,-1> E3 ## E2 ## E3; }; \
-	struct { detail::_swizzle<3, T, P, V, 3,3,0,-1> E3 ## E3 ## E0; }; \
-	struct { detail::_swizzle<3, T, P, V, 3,3,1,-1> E3 ## E3 ## E1; }; \
-	struct { detail::_swizzle<3, T, P, V, 3,3,2,-1> E3 ## E3 ## E2; }; \
-	struct { detail::_swizzle<3, T, P, V, 3,3,3,-1> E3 ## E3 ## E3; };  
+#define _GLM_SWIZZLE4_3_MEMBERS(T, P, E0,E1,E2,E3) \
+	struct { detail::_swizzle<3, T, P, 0,0,0,-1> E0 ## E0 ## E0; }; \
+	struct { detail::_swizzle<3, T, P, 0,0,1,-1> E0 ## E0 ## E1; }; \
+	struct { detail::_swizzle<3, T, P, 0,0,2,-1> E0 ## E0 ## E2; }; \
+	struct { detail::_swizzle<3, T, P, 0,0,3,-1> E0 ## E0 ## E3; }; \
+	struct { detail::_swizzle<3, T, P, 0,1,0,-1> E0 ## E1 ## E0; }; \
+	struct { detail::_swizzle<3, T, P, 0,1,1,-1> E0 ## E1 ## E1; }; \
+	struct { detail::_swizzle<3, T, P, 0,1,2,-1> E0 ## E1 ## E2; }; \
+	struct { detail::_swizzle<3, T, P, 0,1,3,-1> E0 ## E1 ## E3; }; \
+	struct { detail::_swizzle<3, T, P, 0,2,0,-1> E0 ## E2 ## E0; }; \
+	struct { detail::_swizzle<3, T, P, 0,2,1,-1> E0 ## E2 ## E1; }; \
+	struct { detail::_swizzle<3, T, P, 0,2,2,-1> E0 ## E2 ## E2; }; \
+	struct { detail::_swizzle<3, T, P, 0,2,3,-1> E0 ## E2 ## E3; }; \
+	struct { detail::_swizzle<3, T, P, 0,3,0,-1> E0 ## E3 ## E0; }; \
+	struct { detail::_swizzle<3, T, P, 0,3,1,-1> E0 ## E3 ## E1; }; \
+	struct { detail::_swizzle<3, T, P, 0,3,2,-1> E0 ## E3 ## E2; }; \
+	struct { detail::_swizzle<3, T, P, 0,3,3,-1> E0 ## E3 ## E3; }; \
+	struct { detail::_swizzle<3, T, P, 1,0,0,-1> E1 ## E0 ## E0; }; \
+	struct { detail::_swizzle<3, T, P, 1,0,1,-1> E1 ## E0 ## E1; }; \
+	struct { detail::_swizzle<3, T, P, 1,0,2,-1> E1 ## E0 ## E2; }; \
+	struct { detail::_swizzle<3, T, P, 1,0,3,-1> E1 ## E0 ## E3; }; \
+	struct { detail::_swizzle<3, T, P, 1,1,0,-1> E1 ## E1 ## E0; }; \
+	struct { detail::_swizzle<3, T, P, 1,1,1,-1> E1 ## E1 ## E1; }; \
+	struct { detail::_swizzle<3, T, P, 1,1,2,-1> E1 ## E1 ## E2; }; \
+	struct { detail::_swizzle<3, T, P, 1,1,3,-1> E1 ## E1 ## E3; }; \
+	struct { detail::_swizzle<3, T, P, 1,2,0,-1> E1 ## E2 ## E0; }; \
+	struct { detail::_swizzle<3, T, P, 1,2,1,-1> E1 ## E2 ## E1; }; \
+	struct { detail::_swizzle<3, T, P, 1,2,2,-1> E1 ## E2 ## E2; }; \
+	struct { detail::_swizzle<3, T, P, 1,2,3,-1> E1 ## E2 ## E3; }; \
+	struct { detail::_swizzle<3, T, P, 1,3,0,-1> E1 ## E3 ## E0; }; \
+	struct { detail::_swizzle<3, T, P, 1,3,1,-1> E1 ## E3 ## E1; }; \
+	struct { detail::_swizzle<3, T, P, 1,3,2,-1> E1 ## E3 ## E2; }; \
+	struct { detail::_swizzle<3, T, P, 1,3,3,-1> E1 ## E3 ## E3; }; \
+	struct { detail::_swizzle<3, T, P, 2,0,0,-1> E2 ## E0 ## E0; }; \
+	struct { detail::_swizzle<3, T, P, 2,0,1,-1> E2 ## E0 ## E1; }; \
+	struct { detail::_swizzle<3, T, P, 2,0,2,-1> E2 ## E0 ## E2; }; \
+	struct { detail::_swizzle<3, T, P, 2,0,3,-1> E2 ## E0 ## E3; }; \
+	struct { detail::_swizzle<3, T, P, 2,1,0,-1> E2 ## E1 ## E0; }; \
+	struct { detail::_swizzle<3, T, P, 2,1,1,-1> E2 ## E1 ## E1; }; \
+	struct { detail::_swizzle<3, T, P, 2,1,2,-1> E2 ## E1 ## E2; }; \
+	struct { detail::_swizzle<3, T, P, 2,1,3,-1> E2 ## E1 ## E3; }; \
+	struct { detail::_swizzle<3, T, P, 2,2,0,-1> E2 ## E2 ## E0; }; \
+	struct { detail::_swizzle<3, T, P, 2,2,1,-1> E2 ## E2 ## E1; }; \
+	struct { detail::_swizzle<3, T, P, 2,2,2,-1> E2 ## E2 ## E2; }; \
+	struct { detail::_swizzle<3, T, P, 2,2,3,-1> E2 ## E2 ## E3; }; \
+	struct { detail::_swizzle<3, T, P, 2,3,0,-1> E2 ## E3 ## E0; }; \
+	struct { detail::_swizzle<3, T, P, 2,3,1,-1> E2 ## E3 ## E1; }; \
+	struct { detail::_swizzle<3, T, P, 2,3,2,-1> E2 ## E3 ## E2; }; \
+	struct { detail::_swizzle<3, T, P, 2,3,3,-1> E2 ## E3 ## E3; }; \
+	struct { detail::_swizzle<3, T, P, 3,0,0,-1> E3 ## E0 ## E0; }; \
+	struct { detail::_swizzle<3, T, P, 3,0,1,-1> E3 ## E0 ## E1; }; \
+	struct { detail::_swizzle<3, T, P, 3,0,2,-1> E3 ## E0 ## E2; }; \
+	struct { detail::_swizzle<3, T, P, 3,0,3,-1> E3 ## E0 ## E3; }; \
+	struct { detail::_swizzle<3, T, P, 3,1,0,-1> E3 ## E1 ## E0; }; \
+	struct { detail::_swizzle<3, T, P, 3,1,1,-1> E3 ## E1 ## E1; }; \
+	struct { detail::_swizzle<3, T, P, 3,1,2,-1> E3 ## E1 ## E2; }; \
+	struct { detail::_swizzle<3, T, P, 3,1,3,-1> E3 ## E1 ## E3; }; \
+	struct { detail::_swizzle<3, T, P, 3,2,0,-1> E3 ## E2 ## E0; }; \
+	struct { detail::_swizzle<3, T, P, 3,2,1,-1> E3 ## E2 ## E1; }; \
+	struct { detail::_swizzle<3, T, P, 3,2,2,-1> E3 ## E2 ## E2; }; \
+	struct { detail::_swizzle<3, T, P, 3,2,3,-1> E3 ## E2 ## E3; }; \
+	struct { detail::_swizzle<3, T, P, 3,3,0,-1> E3 ## E3 ## E0; }; \
+	struct { detail::_swizzle<3, T, P, 3,3,1,-1> E3 ## E3 ## E1; }; \
+	struct { detail::_swizzle<3, T, P, 3,3,2,-1> E3 ## E3 ## E2; }; \
+	struct { detail::_swizzle<3, T, P, 3,3,3,-1> E3 ## E3 ## E3; };  
 
-#define _GLM_SWIZZLE4_4_MEMBERS(T, P, V, E0,E1,E2,E3) \
-	struct { detail::_swizzle<4, T, P, V, 0,0,0,0> E0 ## E0 ## E0 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,0,0,1> E0 ## E0 ## E0 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,0,0,2> E0 ## E0 ## E0 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,0,0,3> E0 ## E0 ## E0 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,0,1,0> E0 ## E0 ## E1 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,0,1,1> E0 ## E0 ## E1 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,0,1,2> E0 ## E0 ## E1 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,0,1,3> E0 ## E0 ## E1 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,0,2,0> E0 ## E0 ## E2 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,0,2,1> E0 ## E0 ## E2 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,0,2,2> E0 ## E0 ## E2 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,0,2,3> E0 ## E0 ## E2 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,0,3,0> E0 ## E0 ## E3 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,0,3,1> E0 ## E0 ## E3 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,0,3,2> E0 ## E0 ## E3 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,0,3,3> E0 ## E0 ## E3 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,1,0,0> E0 ## E1 ## E0 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,1,0,1> E0 ## E1 ## E0 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,1,0,2> E0 ## E1 ## E0 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,1,0,3> E0 ## E1 ## E0 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,1,1,0> E0 ## E1 ## E1 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,1,1,1> E0 ## E1 ## E1 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,1,1,2> E0 ## E1 ## E1 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,1,1,3> E0 ## E1 ## E1 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,1,2,0> E0 ## E1 ## E2 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,1,2,1> E0 ## E1 ## E2 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,1,2,2> E0 ## E1 ## E2 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,1,2,3> E0 ## E1 ## E2 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,1,3,0> E0 ## E1 ## E3 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,1,3,1> E0 ## E1 ## E3 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,1,3,2> E0 ## E1 ## E3 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,1,3,3> E0 ## E1 ## E3 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,2,0,0> E0 ## E2 ## E0 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,2,0,1> E0 ## E2 ## E0 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,2,0,2> E0 ## E2 ## E0 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,2,0,3> E0 ## E2 ## E0 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,2,1,0> E0 ## E2 ## E1 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,2,1,1> E0 ## E2 ## E1 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,2,1,2> E0 ## E2 ## E1 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,2,1,3> E0 ## E2 ## E1 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,2,2,0> E0 ## E2 ## E2 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,2,2,1> E0 ## E2 ## E2 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,2,2,2> E0 ## E2 ## E2 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,2,2,3> E0 ## E2 ## E2 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,2,3,0> E0 ## E2 ## E3 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,2,3,1> E0 ## E2 ## E3 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,2,3,2> E0 ## E2 ## E3 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,2,3,3> E0 ## E2 ## E3 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,3,0,0> E0 ## E3 ## E0 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,3,0,1> E0 ## E3 ## E0 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,3,0,2> E0 ## E3 ## E0 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,3,0,3> E0 ## E3 ## E0 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,3,1,0> E0 ## E3 ## E1 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,3,1,1> E0 ## E3 ## E1 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,3,1,2> E0 ## E3 ## E1 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,3,1,3> E0 ## E3 ## E1 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,3,2,0> E0 ## E3 ## E2 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,3,2,1> E0 ## E3 ## E2 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,3,2,2> E0 ## E3 ## E2 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,3,2,3> E0 ## E3 ## E2 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,3,3,0> E0 ## E3 ## E3 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,3,3,1> E0 ## E3 ## E3 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,3,3,2> E0 ## E3 ## E3 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,3,3,3> E0 ## E3 ## E3 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,0,0,0> E1 ## E0 ## E0 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,0,0,1> E1 ## E0 ## E0 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,0,0,2> E1 ## E0 ## E0 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,0,0,3> E1 ## E0 ## E0 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,0,1,0> E1 ## E0 ## E1 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,0,1,1> E1 ## E0 ## E1 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,0,1,2> E1 ## E0 ## E1 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,0,1,3> E1 ## E0 ## E1 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,0,2,0> E1 ## E0 ## E2 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,0,2,1> E1 ## E0 ## E2 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,0,2,2> E1 ## E0 ## E2 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,0,2,3> E1 ## E0 ## E2 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,0,3,0> E1 ## E0 ## E3 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,0,3,1> E1 ## E0 ## E3 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,0,3,2> E1 ## E0 ## E3 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,0,3,3> E1 ## E0 ## E3 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,1,0,0> E1 ## E1 ## E0 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,1,0,1> E1 ## E1 ## E0 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,1,0,2> E1 ## E1 ## E0 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,1,0,3> E1 ## E1 ## E0 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,1,1,0> E1 ## E1 ## E1 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,1,1,1> E1 ## E1 ## E1 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,1,1,2> E1 ## E1 ## E1 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,1,1,3> E1 ## E1 ## E1 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,1,2,0> E1 ## E1 ## E2 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,1,2,1> E1 ## E1 ## E2 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,1,2,2> E1 ## E1 ## E2 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,1,2,3> E1 ## E1 ## E2 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,1,3,0> E1 ## E1 ## E3 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,1,3,1> E1 ## E1 ## E3 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,1,3,2> E1 ## E1 ## E3 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,1,3,3> E1 ## E1 ## E3 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,2,0,0> E1 ## E2 ## E0 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,2,0,1> E1 ## E2 ## E0 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,2,0,2> E1 ## E2 ## E0 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,2,0,3> E1 ## E2 ## E0 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,2,1,0> E1 ## E2 ## E1 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,2,1,1> E1 ## E2 ## E1 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,2,1,2> E1 ## E2 ## E1 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,2,1,3> E1 ## E2 ## E1 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,2,2,0> E1 ## E2 ## E2 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,2,2,1> E1 ## E2 ## E2 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,2,2,2> E1 ## E2 ## E2 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,2,2,3> E1 ## E2 ## E2 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,2,3,0> E1 ## E2 ## E3 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,2,3,1> E1 ## E2 ## E3 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,2,3,2> E1 ## E2 ## E3 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,2,3,3> E1 ## E2 ## E3 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,3,0,0> E1 ## E3 ## E0 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,3,0,1> E1 ## E3 ## E0 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,3,0,2> E1 ## E3 ## E0 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,3,0,3> E1 ## E3 ## E0 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,3,1,0> E1 ## E3 ## E1 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,3,1,1> E1 ## E3 ## E1 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,3,1,2> E1 ## E3 ## E1 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,3,1,3> E1 ## E3 ## E1 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,3,2,0> E1 ## E3 ## E2 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,3,2,1> E1 ## E3 ## E2 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,3,2,2> E1 ## E3 ## E2 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,3,2,3> E1 ## E3 ## E2 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,3,3,0> E1 ## E3 ## E3 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,3,3,1> E1 ## E3 ## E3 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,3,3,2> E1 ## E3 ## E3 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,3,3,3> E1 ## E3 ## E3 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,0,0,0> E2 ## E0 ## E0 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,0,0,1> E2 ## E0 ## E0 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,0,0,2> E2 ## E0 ## E0 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,0,0,3> E2 ## E0 ## E0 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,0,1,0> E2 ## E0 ## E1 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,0,1,1> E2 ## E0 ## E1 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,0,1,2> E2 ## E0 ## E1 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,0,1,3> E2 ## E0 ## E1 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,0,2,0> E2 ## E0 ## E2 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,0,2,1> E2 ## E0 ## E2 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,0,2,2> E2 ## E0 ## E2 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,0,2,3> E2 ## E0 ## E2 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,0,3,0> E2 ## E0 ## E3 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,0,3,1> E2 ## E0 ## E3 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,0,3,2> E2 ## E0 ## E3 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,0,3,3> E2 ## E0 ## E3 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,1,0,0> E2 ## E1 ## E0 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,1,0,1> E2 ## E1 ## E0 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,1,0,2> E2 ## E1 ## E0 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,1,0,3> E2 ## E1 ## E0 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,1,1,0> E2 ## E1 ## E1 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,1,1,1> E2 ## E1 ## E1 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,1,1,2> E2 ## E1 ## E1 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,1,1,3> E2 ## E1 ## E1 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,1,2,0> E2 ## E1 ## E2 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,1,2,1> E2 ## E1 ## E2 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,1,2,2> E2 ## E1 ## E2 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,1,2,3> E2 ## E1 ## E2 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,1,3,0> E2 ## E1 ## E3 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,1,3,1> E2 ## E1 ## E3 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,1,3,2> E2 ## E1 ## E3 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,1,3,3> E2 ## E1 ## E3 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,2,0,0> E2 ## E2 ## E0 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,2,0,1> E2 ## E2 ## E0 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,2,0,2> E2 ## E2 ## E0 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,2,0,3> E2 ## E2 ## E0 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,2,1,0> E2 ## E2 ## E1 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,2,1,1> E2 ## E2 ## E1 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,2,1,2> E2 ## E2 ## E1 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,2,1,3> E2 ## E2 ## E1 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,2,2,0> E2 ## E2 ## E2 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,2,2,1> E2 ## E2 ## E2 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,2,2,2> E2 ## E2 ## E2 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,2,2,3> E2 ## E2 ## E2 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,2,3,0> E2 ## E2 ## E3 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,2,3,1> E2 ## E2 ## E3 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,2,3,2> E2 ## E2 ## E3 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,2,3,3> E2 ## E2 ## E3 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,3,0,0> E2 ## E3 ## E0 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,3,0,1> E2 ## E3 ## E0 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,3,0,2> E2 ## E3 ## E0 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,3,0,3> E2 ## E3 ## E0 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,3,1,0> E2 ## E3 ## E1 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,3,1,1> E2 ## E3 ## E1 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,3,1,2> E2 ## E3 ## E1 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,3,1,3> E2 ## E3 ## E1 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,3,2,0> E2 ## E3 ## E2 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,3,2,1> E2 ## E3 ## E2 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,3,2,2> E2 ## E3 ## E2 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,3,2,3> E2 ## E3 ## E2 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,3,3,0> E2 ## E3 ## E3 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,3,3,1> E2 ## E3 ## E3 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,3,3,2> E2 ## E3 ## E3 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,3,3,3> E2 ## E3 ## E3 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,0,0,0> E3 ## E0 ## E0 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,0,0,1> E3 ## E0 ## E0 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,0,0,2> E3 ## E0 ## E0 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,0,0,3> E3 ## E0 ## E0 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,0,1,0> E3 ## E0 ## E1 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,0,1,1> E3 ## E0 ## E1 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,0,1,2> E3 ## E0 ## E1 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,0,1,3> E3 ## E0 ## E1 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,0,2,0> E3 ## E0 ## E2 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,0,2,1> E3 ## E0 ## E2 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,0,2,2> E3 ## E0 ## E2 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,0,2,3> E3 ## E0 ## E2 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,0,3,0> E3 ## E0 ## E3 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,0,3,1> E3 ## E0 ## E3 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,0,3,2> E3 ## E0 ## E3 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,0,3,3> E3 ## E0 ## E3 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,1,0,0> E3 ## E1 ## E0 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,1,0,1> E3 ## E1 ## E0 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,1,0,2> E3 ## E1 ## E0 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,1,0,3> E3 ## E1 ## E0 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,1,1,0> E3 ## E1 ## E1 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,1,1,1> E3 ## E1 ## E1 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,1,1,2> E3 ## E1 ## E1 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,1,1,3> E3 ## E1 ## E1 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,1,2,0> E3 ## E1 ## E2 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,1,2,1> E3 ## E1 ## E2 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,1,2,2> E3 ## E1 ## E2 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,1,2,3> E3 ## E1 ## E2 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,1,3,0> E3 ## E1 ## E3 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,1,3,1> E3 ## E1 ## E3 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,1,3,2> E3 ## E1 ## E3 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,1,3,3> E3 ## E1 ## E3 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,2,0,0> E3 ## E2 ## E0 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,2,0,1> E3 ## E2 ## E0 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,2,0,2> E3 ## E2 ## E0 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,2,0,3> E3 ## E2 ## E0 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,2,1,0> E3 ## E2 ## E1 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,2,1,1> E3 ## E2 ## E1 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,2,1,2> E3 ## E2 ## E1 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,2,1,3> E3 ## E2 ## E1 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,2,2,0> E3 ## E2 ## E2 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,2,2,1> E3 ## E2 ## E2 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,2,2,2> E3 ## E2 ## E2 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,2,2,3> E3 ## E2 ## E2 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,2,3,0> E3 ## E2 ## E3 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,2,3,1> E3 ## E2 ## E3 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,2,3,2> E3 ## E2 ## E3 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,2,3,3> E3 ## E2 ## E3 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,3,0,0> E3 ## E3 ## E0 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,3,0,1> E3 ## E3 ## E0 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,3,0,2> E3 ## E3 ## E0 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,3,0,3> E3 ## E3 ## E0 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,3,1,0> E3 ## E3 ## E1 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,3,1,1> E3 ## E3 ## E1 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,3,1,2> E3 ## E3 ## E1 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,3,1,3> E3 ## E3 ## E1 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,3,2,0> E3 ## E3 ## E2 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,3,2,1> E3 ## E3 ## E2 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,3,2,2> E3 ## E3 ## E2 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,3,2,3> E3 ## E3 ## E2 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,3,3,0> E3 ## E3 ## E3 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,3,3,1> E3 ## E3 ## E3 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,3,3,2> E3 ## E3 ## E3 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,3,3,3> E3 ## E3 ## E3 ## E3; };
+#define _GLM_SWIZZLE4_4_MEMBERS(T, P, E0,E1,E2,E3) \
+	struct { detail::_swizzle<4, T, P, 0,0,0,0> E0 ## E0 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, 0,0,0,1> E0 ## E0 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, 0,0,0,2> E0 ## E0 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, 0,0,0,3> E0 ## E0 ## E0 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, 0,0,1,0> E0 ## E0 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, 0,0,1,1> E0 ## E0 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, 0,0,1,2> E0 ## E0 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, 0,0,1,3> E0 ## E0 ## E1 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, 0,0,2,0> E0 ## E0 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, 0,0,2,1> E0 ## E0 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, 0,0,2,2> E0 ## E0 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, 0,0,2,3> E0 ## E0 ## E2 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, 0,0,3,0> E0 ## E0 ## E3 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, 0,0,3,1> E0 ## E0 ## E3 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, 0,0,3,2> E0 ## E0 ## E3 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, 0,0,3,3> E0 ## E0 ## E3 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, 0,1,0,0> E0 ## E1 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, 0,1,0,1> E0 ## E1 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, 0,1,0,2> E0 ## E1 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, 0,1,0,3> E0 ## E1 ## E0 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, 0,1,1,0> E0 ## E1 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, 0,1,1,1> E0 ## E1 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, 0,1,1,2> E0 ## E1 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, 0,1,1,3> E0 ## E1 ## E1 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, 0,1,2,0> E0 ## E1 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, 0,1,2,1> E0 ## E1 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, 0,1,2,2> E0 ## E1 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, 0,1,2,3> E0 ## E1 ## E2 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, 0,1,3,0> E0 ## E1 ## E3 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, 0,1,3,1> E0 ## E1 ## E3 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, 0,1,3,2> E0 ## E1 ## E3 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, 0,1,3,3> E0 ## E1 ## E3 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, 0,2,0,0> E0 ## E2 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, 0,2,0,1> E0 ## E2 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, 0,2,0,2> E0 ## E2 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, 0,2,0,3> E0 ## E2 ## E0 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, 0,2,1,0> E0 ## E2 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, 0,2,1,1> E0 ## E2 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, 0,2,1,2> E0 ## E2 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, 0,2,1,3> E0 ## E2 ## E1 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, 0,2,2,0> E0 ## E2 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, 0,2,2,1> E0 ## E2 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, 0,2,2,2> E0 ## E2 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, 0,2,2,3> E0 ## E2 ## E2 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, 0,2,3,0> E0 ## E2 ## E3 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, 0,2,3,1> E0 ## E2 ## E3 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, 0,2,3,2> E0 ## E2 ## E3 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, 0,2,3,3> E0 ## E2 ## E3 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, 0,3,0,0> E0 ## E3 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, 0,3,0,1> E0 ## E3 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, 0,3,0,2> E0 ## E3 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, 0,3,0,3> E0 ## E3 ## E0 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, 0,3,1,0> E0 ## E3 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, 0,3,1,1> E0 ## E3 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, 0,3,1,2> E0 ## E3 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, 0,3,1,3> E0 ## E3 ## E1 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, 0,3,2,0> E0 ## E3 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, 0,3,2,1> E0 ## E3 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, 0,3,2,2> E0 ## E3 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, 0,3,2,3> E0 ## E3 ## E2 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, 0,3,3,0> E0 ## E3 ## E3 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, 0,3,3,1> E0 ## E3 ## E3 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, 0,3,3,2> E0 ## E3 ## E3 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, 0,3,3,3> E0 ## E3 ## E3 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, 1,0,0,0> E1 ## E0 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, 1,0,0,1> E1 ## E0 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, 1,0,0,2> E1 ## E0 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, 1,0,0,3> E1 ## E0 ## E0 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, 1,0,1,0> E1 ## E0 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, 1,0,1,1> E1 ## E0 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, 1,0,1,2> E1 ## E0 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, 1,0,1,3> E1 ## E0 ## E1 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, 1,0,2,0> E1 ## E0 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, 1,0,2,1> E1 ## E0 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, 1,0,2,2> E1 ## E0 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, 1,0,2,3> E1 ## E0 ## E2 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, 1,0,3,0> E1 ## E0 ## E3 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, 1,0,3,1> E1 ## E0 ## E3 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, 1,0,3,2> E1 ## E0 ## E3 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, 1,0,3,3> E1 ## E0 ## E3 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, 1,1,0,0> E1 ## E1 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, 1,1,0,1> E1 ## E1 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, 1,1,0,2> E1 ## E1 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, 1,1,0,3> E1 ## E1 ## E0 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, 1,1,1,0> E1 ## E1 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, 1,1,1,1> E1 ## E1 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, 1,1,1,2> E1 ## E1 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, 1,1,1,3> E1 ## E1 ## E1 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, 1,1,2,0> E1 ## E1 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, 1,1,2,1> E1 ## E1 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, 1,1,2,2> E1 ## E1 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, 1,1,2,3> E1 ## E1 ## E2 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, 1,1,3,0> E1 ## E1 ## E3 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, 1,1,3,1> E1 ## E1 ## E3 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, 1,1,3,2> E1 ## E1 ## E3 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, 1,1,3,3> E1 ## E1 ## E3 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, 1,2,0,0> E1 ## E2 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, 1,2,0,1> E1 ## E2 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, 1,2,0,2> E1 ## E2 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, 1,2,0,3> E1 ## E2 ## E0 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, 1,2,1,0> E1 ## E2 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, 1,2,1,1> E1 ## E2 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, 1,2,1,2> E1 ## E2 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, 1,2,1,3> E1 ## E2 ## E1 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, 1,2,2,0> E1 ## E2 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, 1,2,2,1> E1 ## E2 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, 1,2,2,2> E1 ## E2 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, 1,2,2,3> E1 ## E2 ## E2 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, 1,2,3,0> E1 ## E2 ## E3 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, 1,2,3,1> E1 ## E2 ## E3 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, 1,2,3,2> E1 ## E2 ## E3 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, 1,2,3,3> E1 ## E2 ## E3 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, 1,3,0,0> E1 ## E3 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, 1,3,0,1> E1 ## E3 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, 1,3,0,2> E1 ## E3 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, 1,3,0,3> E1 ## E3 ## E0 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, 1,3,1,0> E1 ## E3 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, 1,3,1,1> E1 ## E3 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, 1,3,1,2> E1 ## E3 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, 1,3,1,3> E1 ## E3 ## E1 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, 1,3,2,0> E1 ## E3 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, 1,3,2,1> E1 ## E3 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, 1,3,2,2> E1 ## E3 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, 1,3,2,3> E1 ## E3 ## E2 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, 1,3,3,0> E1 ## E3 ## E3 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, 1,3,3,1> E1 ## E3 ## E3 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, 1,3,3,2> E1 ## E3 ## E3 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, 1,3,3,3> E1 ## E3 ## E3 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, 2,0,0,0> E2 ## E0 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, 2,0,0,1> E2 ## E0 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, 2,0,0,2> E2 ## E0 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, 2,0,0,3> E2 ## E0 ## E0 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, 2,0,1,0> E2 ## E0 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, 2,0,1,1> E2 ## E0 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, 2,0,1,2> E2 ## E0 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, 2,0,1,3> E2 ## E0 ## E1 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, 2,0,2,0> E2 ## E0 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, 2,0,2,1> E2 ## E0 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, 2,0,2,2> E2 ## E0 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, 2,0,2,3> E2 ## E0 ## E2 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, 2,0,3,0> E2 ## E0 ## E3 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, 2,0,3,1> E2 ## E0 ## E3 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, 2,0,3,2> E2 ## E0 ## E3 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, 2,0,3,3> E2 ## E0 ## E3 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, 2,1,0,0> E2 ## E1 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, 2,1,0,1> E2 ## E1 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, 2,1,0,2> E2 ## E1 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, 2,1,0,3> E2 ## E1 ## E0 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, 2,1,1,0> E2 ## E1 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, 2,1,1,1> E2 ## E1 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, 2,1,1,2> E2 ## E1 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, 2,1,1,3> E2 ## E1 ## E1 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, 2,1,2,0> E2 ## E1 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, 2,1,2,1> E2 ## E1 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, 2,1,2,2> E2 ## E1 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, 2,1,2,3> E2 ## E1 ## E2 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, 2,1,3,0> E2 ## E1 ## E3 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, 2,1,3,1> E2 ## E1 ## E3 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, 2,1,3,2> E2 ## E1 ## E3 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, 2,1,3,3> E2 ## E1 ## E3 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, 2,2,0,0> E2 ## E2 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, 2,2,0,1> E2 ## E2 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, 2,2,0,2> E2 ## E2 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, 2,2,0,3> E2 ## E2 ## E0 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, 2,2,1,0> E2 ## E2 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, 2,2,1,1> E2 ## E2 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, 2,2,1,2> E2 ## E2 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, 2,2,1,3> E2 ## E2 ## E1 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, 2,2,2,0> E2 ## E2 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, 2,2,2,1> E2 ## E2 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, 2,2,2,2> E2 ## E2 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, 2,2,2,3> E2 ## E2 ## E2 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, 2,2,3,0> E2 ## E2 ## E3 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, 2,2,3,1> E2 ## E2 ## E3 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, 2,2,3,2> E2 ## E2 ## E3 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, 2,2,3,3> E2 ## E2 ## E3 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, 2,3,0,0> E2 ## E3 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, 2,3,0,1> E2 ## E3 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, 2,3,0,2> E2 ## E3 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, 2,3,0,3> E2 ## E3 ## E0 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, 2,3,1,0> E2 ## E3 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, 2,3,1,1> E2 ## E3 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, 2,3,1,2> E2 ## E3 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, 2,3,1,3> E2 ## E3 ## E1 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, 2,3,2,0> E2 ## E3 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, 2,3,2,1> E2 ## E3 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, 2,3,2,2> E2 ## E3 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, 2,3,2,3> E2 ## E3 ## E2 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, 2,3,3,0> E2 ## E3 ## E3 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, 2,3,3,1> E2 ## E3 ## E3 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, 2,3,3,2> E2 ## E3 ## E3 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, 2,3,3,3> E2 ## E3 ## E3 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, 3,0,0,0> E3 ## E0 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, 3,0,0,1> E3 ## E0 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, 3,0,0,2> E3 ## E0 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, 3,0,0,3> E3 ## E0 ## E0 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, 3,0,1,0> E3 ## E0 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, 3,0,1,1> E3 ## E0 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, 3,0,1,2> E3 ## E0 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, 3,0,1,3> E3 ## E0 ## E1 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, 3,0,2,0> E3 ## E0 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, 3,0,2,1> E3 ## E0 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, 3,0,2,2> E3 ## E0 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, 3,0,2,3> E3 ## E0 ## E2 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, 3,0,3,0> E3 ## E0 ## E3 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, 3,0,3,1> E3 ## E0 ## E3 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, 3,0,3,2> E3 ## E0 ## E3 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, 3,0,3,3> E3 ## E0 ## E3 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, 3,1,0,0> E3 ## E1 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, 3,1,0,1> E3 ## E1 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, 3,1,0,2> E3 ## E1 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, 3,1,0,3> E3 ## E1 ## E0 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, 3,1,1,0> E3 ## E1 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, 3,1,1,1> E3 ## E1 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, 3,1,1,2> E3 ## E1 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, 3,1,1,3> E3 ## E1 ## E1 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, 3,1,2,0> E3 ## E1 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, 3,1,2,1> E3 ## E1 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, 3,1,2,2> E3 ## E1 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, 3,1,2,3> E3 ## E1 ## E2 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, 3,1,3,0> E3 ## E1 ## E3 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, 3,1,3,1> E3 ## E1 ## E3 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, 3,1,3,2> E3 ## E1 ## E3 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, 3,1,3,3> E3 ## E1 ## E3 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, 3,2,0,0> E3 ## E2 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, 3,2,0,1> E3 ## E2 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, 3,2,0,2> E3 ## E2 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, 3,2,0,3> E3 ## E2 ## E0 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, 3,2,1,0> E3 ## E2 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, 3,2,1,1> E3 ## E2 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, 3,2,1,2> E3 ## E2 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, 3,2,1,3> E3 ## E2 ## E1 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, 3,2,2,0> E3 ## E2 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, 3,2,2,1> E3 ## E2 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, 3,2,2,2> E3 ## E2 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, 3,2,2,3> E3 ## E2 ## E2 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, 3,2,3,0> E3 ## E2 ## E3 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, 3,2,3,1> E3 ## E2 ## E3 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, 3,2,3,2> E3 ## E2 ## E3 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, 3,2,3,3> E3 ## E2 ## E3 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, 3,3,0,0> E3 ## E3 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, 3,3,0,1> E3 ## E3 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, 3,3,0,2> E3 ## E3 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, 3,3,0,3> E3 ## E3 ## E0 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, 3,3,1,0> E3 ## E3 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, 3,3,1,1> E3 ## E3 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, 3,3,1,2> E3 ## E3 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, 3,3,1,3> E3 ## E3 ## E1 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, 3,3,2,0> E3 ## E3 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, 3,3,2,1> E3 ## E3 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, 3,3,2,2> E3 ## E3 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, 3,3,2,3> E3 ## E3 ## E2 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, 3,3,3,0> E3 ## E3 ## E3 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, 3,3,3,1> E3 ## E3 ## E3 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, 3,3,3,2> E3 ## E3 ## E3 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, 3,3,3,3> E3 ## E3 ## E3 ## E3; };
diff --git a/glm/detail/_swizzle_func.hpp b/glm/detail/_swizzle_func.hpp
index 4b37edbb..0ca9bd8e 100644
--- a/glm/detail/_swizzle_func.hpp
+++ b/glm/detail/_swizzle_func.hpp
@@ -3,694 +3,683 @@
 
 #pragma once
 
-#define GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, CONST, A, B)	\
-	SWIZZLED_TYPE<TMPL_TYPE, PRECISION> A ## B() CONST												\
-	{																								\
-		return SWIZZLED_TYPE<TMPL_TYPE, PRECISION>(this->A, this->B);								\
+#define GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, CONST, A, B)	\
+	vec<2, T, P> A ## B() CONST							\
+	{													\
+		return vec<2, T, P>(this->A, this->B);			\
 	}
 
-#define GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, CONST, A, B, C)		\
-	SWIZZLED_TYPE<TMPL_TYPE, PRECISION> A ## B ## C() CONST												\
-	{																									\
-		return SWIZZLED_TYPE<TMPL_TYPE, PRECISION>(this->A, this->B, this->C);							\
+#define GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, CONST, A, B, C)		\
+	vec<3, T, P> A ## B ## C() CONST							\
+	{															\
+		return vec<3, T, P>(this->A, this->B, this->C);			\
 	}
 
-#define GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, CONST, A, B, C, D)	\
-	SWIZZLED_TYPE<TMPL_TYPE, PRECISION> A ## B ## C ## D() CONST										\
-	{																									\
-		return SWIZZLED_TYPE<TMPL_TYPE, PRECISION>(this->A, this->B, this->C, this->D);					\
+#define GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, CONST, A, B, C, D)					\
+	vec<4, T, P> A ## B ## C ## D() CONST									\
+	{																		\
+		return vec<4, T, P>(this->A, this->B, this->C, this->D);			\
 	}
 
-#define GLM_SWIZZLE_GEN_VEC2_ENTRY_DEF(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, CONST, A, B)	\
-	template <typename TMPL_TYPE>																		\
-	SWIZZLED_TYPE<TMPL_TYPE> CLASS_TYPE<TMPL_TYPE, PRECISION>::A ## B() CONST							\
-	{																									\
-		return SWIZZLED_TYPE<TMPL_TYPE, PRECISION>(this->A, this->B);									\
+#define GLM_SWIZZLE_GEN_VEC2_ENTRY_DEF(T, P, L, CONST, A, B)	\
+	template<typename T>										\
+	vec<L, T, P> vec<L, T, P>::A ## B() CONST					\
+	{															\
+		return vec<2, T, P>(this->A, this->B);					\
 	}
 
-#define GLM_SWIZZLE_GEN_VEC3_ENTRY_DEF(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, CONST, A, B, C)		\
-	template <typename TMPL_TYPE>																			\
-	SWIZZLED_TYPE<TMPL_TYPE> CLASS_TYPE<TMPL_TYPE, PRECISION>::A ## B ## C() CONST							\
-	{																										\
-		return SWIZZLED_TYPE<TMPL_TYPE, PRECISION>(this->A, this->B, this->C);								\
+#define GLM_SWIZZLE_GEN_VEC3_ENTRY_DEF(T, P, L, CONST, A, B, C)		\
+	template<typename T>											\
+	vec<3, T, P> vec<L, T, P>::A ## B ## C() CONST					\
+	{																\
+		return vec<3, T, P>(this->A, this->B, this->C);				\
 	}
 
-#define GLM_SWIZZLE_GEN_VEC4_ENTRY_DEF(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, CONST, A, B, C, D)	\
-	template <typename TMPL_TYPE>																			\
-	SWIZZLED_TYPE<TMPL_TYPE> CLASS_TYPE<TMPL_TYPE, PRECISION>::A ## B ## C ## D() CONST						\
-	{																										\
-		return SWIZZLED_TYPE<TMPL_TYPE, PRECISION>(this->A, this->B, this->C, this->D);						\
+#define GLM_SWIZZLE_GEN_VEC4_ENTRY_DEF(T, P, L, CONST, A, B, C, D)		\
+	template<typename T>												\
+	vec<4, T, P> vec<L, T, P>::A ## B ## C ## D() CONST					\
+	{																	\
+		return vec<4, T, P>(this->A, this->B, this->C, this->D);		\
 	}
 
 #define GLM_MUTABLE
 
-#define GLM_SWIZZLE_GEN_REF2_FROM_VEC2_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, A, B) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, B, A)
+#define GLM_SWIZZLE_GEN_REF2_FROM_VEC2_SWIZZLE(T, P, A, B) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, 2, GLM_MUTABLE, A, B) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, 2, GLM_MUTABLE, B, A)
 
-#define GLM_SWIZZLE_GEN_REF_FROM_VEC2(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE) \
-	GLM_SWIZZLE_GEN_REF2_FROM_VEC2_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, x, y) \
-	GLM_SWIZZLE_GEN_REF2_FROM_VEC2_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, r, g) \
-	GLM_SWIZZLE_GEN_REF2_FROM_VEC2_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, s, t)
+#define GLM_SWIZZLE_GEN_REF_FROM_VEC2(T, P) \
+	GLM_SWIZZLE_GEN_REF2_FROM_VEC2_SWIZZLE(T, P, x, y) \
+	GLM_SWIZZLE_GEN_REF2_FROM_VEC2_SWIZZLE(T, P, r, g) \
+	GLM_SWIZZLE_GEN_REF2_FROM_VEC2_SWIZZLE(T, P, s, t)
 
-//GLM_SWIZZLE_GEN_REF_FROM_VEC2(valType, detail::vec2, detail::ref2)
+#define GLM_SWIZZLE_GEN_REF2_FROM_VEC3_SWIZZLE(T, P, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, A, B) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, A, C) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, B, A) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, B, C) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, C, A) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, C, B)
 
-#define GLM_SWIZZLE_GEN_REF2_FROM_VEC3_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B, C) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, A, B) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, A, C) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, B, A) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, B, C) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, C, A) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, C, B)
+#define GLM_SWIZZLE_GEN_REF3_FROM_VEC3_SWIZZLE(T, P, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, GLM_MUTABLE, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, GLM_MUTABLE, A, C, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, GLM_MUTABLE, B, A, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, GLM_MUTABLE, B, C, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, GLM_MUTABLE, C, A, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, GLM_MUTABLE, C, B, A)
 
-#define GLM_SWIZZLE_GEN_REF3_FROM_VEC3_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, A, B, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, A, C, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, B, A, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, B, C, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, C, A, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, C, B, A)
+#define GLM_SWIZZLE_GEN_REF_FROM_VEC3_COMP(T, P, A, B, C) \
+	GLM_SWIZZLE_GEN_REF3_FROM_VEC3_SWIZZLE(T, P, A, B, C) \
+	GLM_SWIZZLE_GEN_REF2_FROM_VEC3_SWIZZLE(T, P, A, B, C)
 
-#define GLM_SWIZZLE_GEN_REF_FROM_VEC3_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, A, B, C) \
-	GLM_SWIZZLE_GEN_REF3_FROM_VEC3_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC3_TYPE, A, B, C) \
-	GLM_SWIZZLE_GEN_REF2_FROM_VEC3_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, A, B, C)
+#define GLM_SWIZZLE_GEN_REF_FROM_VEC3(T, P) \
+	GLM_SWIZZLE_GEN_REF_FROM_VEC3_COMP(T, P, x, y, z) \
+	GLM_SWIZZLE_GEN_REF_FROM_VEC3_COMP(T, P, r, g, b) \
+	GLM_SWIZZLE_GEN_REF_FROM_VEC3_COMP(T, P, s, t, p)
 
-#define GLM_SWIZZLE_GEN_REF_FROM_VEC3(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE) \
-	GLM_SWIZZLE_GEN_REF_FROM_VEC3_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, x, y, z) \
-	GLM_SWIZZLE_GEN_REF_FROM_VEC3_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, r, g, b) \
-	GLM_SWIZZLE_GEN_REF_FROM_VEC3_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, s, t, p)
+#define GLM_SWIZZLE_GEN_REF2_FROM_VEC4_SWIZZLE(T, P, A, B, C, D) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, A, B) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, A, C) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, A, D) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, B, A) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, B, C) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, B, D) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, C, A) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, C, B) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, C, D) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, D, A) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, D, B) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, D, C)
 
-//GLM_SWIZZLE_GEN_REF_FROM_VEC3(valType, detail::vec3, detail::ref2, detail::ref3)
+#define GLM_SWIZZLE_GEN_REF3_FROM_VEC4_SWIZZLE(T, P, A, B, C, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , A, B, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , A, B, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , A, C, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , A, C, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , A, D, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , A, D, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , B, A, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , B, A, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , B, C, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , B, C, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , B, D, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , B, D, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , C, A, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , C, A, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , C, B, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , C, B, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , C, D, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , C, D, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , D, A, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , D, A, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , D, B, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , D, B, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , D, C, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , D, C, B)
 
-#define GLM_SWIZZLE_GEN_REF2_FROM_VEC4_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B, C, D) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, A, B) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, A, C) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, A, D) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, B, A) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, B, C) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, B, D) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, C, A) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, C, B) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, C, D) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, D, A) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, D, B) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, D, C)
+#define GLM_SWIZZLE_GEN_REF4_FROM_VEC4_SWIZZLE(T, P, A, B, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , A, C, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , A, C, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , A, D, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , A, D, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , A, B, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , A, B, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , B, C, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , B, C, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , B, D, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , B, D, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , B, A, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , B, A, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , C, B, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , C, B, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , C, D, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , C, D, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , C, A, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , C, A, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , D, C, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , D, C, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , D, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , D, A, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , D, B, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , D, B, C, A)
 
-#define GLM_SWIZZLE_GEN_REF3_FROM_VEC4_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B, C, D) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , A, B, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , A, B, D) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , A, C, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , A, C, D) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , A, D, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , A, D, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , B, A, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , B, A, D) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , B, C, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , B, C, D) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , B, D, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , B, D, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , C, A, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , C, A, D) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , C, B, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , C, B, D) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , C, D, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , C, D, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , D, A, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , D, A, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , D, B, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , D, B, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , D, C, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , D, C, B)
+#define GLM_SWIZZLE_GEN_REF_FROM_VEC4_COMP(T, P, A, B, C, D) \
+	GLM_SWIZZLE_GEN_REF2_FROM_VEC4_SWIZZLE(T, P, A, B, C, D) \
+	GLM_SWIZZLE_GEN_REF3_FROM_VEC4_SWIZZLE(T, P, A, B, C, D) \
+	GLM_SWIZZLE_GEN_REF4_FROM_VEC4_SWIZZLE(T, P, A, B, C, D)
 
-#define GLM_SWIZZLE_GEN_REF4_FROM_VEC4_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B, C, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , A, C, B, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , A, C, D, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , A, D, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , A, D, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , A, B, D, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , A, B, C, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , B, C, A, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , B, C, D, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , B, D, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , B, D, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , B, A, D, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , B, A, C, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , C, B, A, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , C, B, D, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , C, D, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , C, D, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , C, A, D, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , C, A, B, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , D, C, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , D, C, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , D, A, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , D, A, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , D, B, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , D, B, C, A)
+#define GLM_SWIZZLE_GEN_REF_FROM_VEC4(T, P) \
+	GLM_SWIZZLE_GEN_REF_FROM_VEC4_COMP(T, P, x, y, z, w) \
+	GLM_SWIZZLE_GEN_REF_FROM_VEC4_COMP(T, P, r, g, b, a) \
+	GLM_SWIZZLE_GEN_REF_FROM_VEC4_COMP(T, P, s, t, p, q)
 
-#define GLM_SWIZZLE_GEN_REF_FROM_VEC4_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, A, B, C, D) \
-	GLM_SWIZZLE_GEN_REF2_FROM_VEC4_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, A, B, C, D) \
-	GLM_SWIZZLE_GEN_REF3_FROM_VEC4_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC3_TYPE, A, B, C, D) \
-	GLM_SWIZZLE_GEN_REF4_FROM_VEC4_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC4_TYPE, A, B, C, D)
+#define GLM_SWIZZLE_GEN_VEC2_FROM_VEC2_SWIZZLE(T, P, A, B) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, A, A) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, A, B) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, B, A) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, B, B)
 
-#define GLM_SWIZZLE_GEN_REF_FROM_VEC4(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE) \
-	GLM_SWIZZLE_GEN_REF_FROM_VEC4_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, x, y, z, w) \
-	GLM_SWIZZLE_GEN_REF_FROM_VEC4_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, r, g, b, a) \
-	GLM_SWIZZLE_GEN_REF_FROM_VEC4_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, s, t, p, q)
+#define GLM_SWIZZLE_GEN_VEC3_FROM_VEC2_SWIZZLE(T, P, A, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, A, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, A, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, B, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, B, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, A, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, A, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, B, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, B, B)
 
-//GLM_SWIZZLE_GEN_REF_FROM_VEC4(valType, detail::vec4, detail::ref2, detail::ref3, detail::ref4)
+#define GLM_SWIZZLE_GEN_VEC4_FROM_VEC2_SWIZZLE(T, P, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, B, B)
 
-#define GLM_SWIZZLE_GEN_VEC2_FROM_VEC2_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B)
+#define GLM_SWIZZLE_GEN_VEC_FROM_VEC2_COMP(T, P, A, B) \
+	GLM_SWIZZLE_GEN_VEC2_FROM_VEC2_SWIZZLE(T, P, A, B) \
+	GLM_SWIZZLE_GEN_VEC3_FROM_VEC2_SWIZZLE(T, P, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_FROM_VEC2_SWIZZLE(T, P, A, B)
 
-#define GLM_SWIZZLE_GEN_VEC3_FROM_VEC2_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B)
+#define GLM_SWIZZLE_GEN_VEC_FROM_VEC2(T, P)			\
+	GLM_SWIZZLE_GEN_VEC_FROM_VEC2_COMP(T, P, x, y)	\
+	GLM_SWIZZLE_GEN_VEC_FROM_VEC2_COMP(T, P, r, g)	\
+	GLM_SWIZZLE_GEN_VEC_FROM_VEC2_COMP(T, P, s, t)
 
-#define GLM_SWIZZLE_GEN_VEC4_FROM_VEC2_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B, B)
+#define GLM_SWIZZLE_GEN_VEC2_FROM_VEC3_SWIZZLE(T, P, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, A, A) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, A, B) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, A, C) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, B, A) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, B, B) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, B, C) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, C, A) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, C, B) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, C, C)
 
-#define GLM_SWIZZLE_GEN_VEC_FROM_VEC2_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, A, B) \
-	GLM_SWIZZLE_GEN_VEC2_FROM_VEC2_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, A, B) \
-	GLM_SWIZZLE_GEN_VEC3_FROM_VEC2_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC3_TYPE, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_FROM_VEC2_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC4_TYPE, A, B)
+#define GLM_SWIZZLE_GEN_VEC3_FROM_VEC3_SWIZZLE(T, P, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, A, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, A, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, A, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, B, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, B, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, C, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, C, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, C, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, A, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, A, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, A, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, B, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, B, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, B, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, C, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, C, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, C, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, A, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, A, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, A, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, B, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, B, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, B, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, C, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, C, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, C, C)
 
-#define GLM_SWIZZLE_GEN_VEC_FROM_VEC2(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE)			\
-	GLM_SWIZZLE_GEN_VEC_FROM_VEC2_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, x, y)	\
-	GLM_SWIZZLE_GEN_VEC_FROM_VEC2_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, r, g)	\
-	GLM_SWIZZLE_GEN_VEC_FROM_VEC2_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, s, t)
+#define GLM_SWIZZLE_GEN_VEC4_FROM_VEC3_SWIZZLE(T, P, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, C, C)
 
-//GLM_SWIZZLE_GEN_VEC_FROM_VEC2(valType, detail::vec2, detail::vec2, detail::vec3, detail::vec4)
+#define GLM_SWIZZLE_GEN_VEC_FROM_VEC3_COMP(T, P, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC2_FROM_VEC3_SWIZZLE(T, P, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC3_FROM_VEC3_SWIZZLE(T, P, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_FROM_VEC3_SWIZZLE(T, P, A, B, C)
 
-#define GLM_SWIZZLE_GEN_VEC2_FROM_VEC3_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B, C) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C)
+#define GLM_SWIZZLE_GEN_VEC_FROM_VEC3(T, P) \
+	GLM_SWIZZLE_GEN_VEC_FROM_VEC3_COMP(T, P, x, y, z) \
+	GLM_SWIZZLE_GEN_VEC_FROM_VEC3_COMP(T, P, r, g, b) \
+	GLM_SWIZZLE_GEN_VEC_FROM_VEC3_COMP(T, P, s, t, p)
 
-#define GLM_SWIZZLE_GEN_VEC3_FROM_VEC3_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, C)
+#define GLM_SWIZZLE_GEN_VEC2_FROM_VEC4_SWIZZLE(T, P, A, B, C, D) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, A, A) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, A, B) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, A, C) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, A, D) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, B, A) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, B, B) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, B, C) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, B, D) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, C, A) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, C, B) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, C, C) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, C, D) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, D, A) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, D, B) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, D, C) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, D, D)
 
-#define GLM_SWIZZLE_GEN_VEC4_FROM_VEC3_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, C, C)
+#define GLM_SWIZZLE_GEN_VEC3_FROM_VEC4_SWIZZLE(T, P, A, B, C, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, A, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, A, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, A, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, A, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, B, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, B, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, B, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, C, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, C, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, C, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, C, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, D, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, D, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, D, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, D, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, A, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, A, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, A, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, A, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, B, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, B, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, B, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, B, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, C, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, C, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, C, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, C, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, D, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, D, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, D, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, D, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, A, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, A, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, A, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, A, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, B, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, B, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, B, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, B, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, C, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, C, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, C, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, C, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, D, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, D, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, D, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, D, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, A, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, A, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, A, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, A, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, B, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, B, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, B, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, B, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, C, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, C, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, C, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, C, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, D, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, D, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, D, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, D, D)
 
-#define GLM_SWIZZLE_GEN_VEC_FROM_VEC3_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, A, B, C) \
-	GLM_SWIZZLE_GEN_VEC2_FROM_VEC3_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, A, B, C) \
-	GLM_SWIZZLE_GEN_VEC3_FROM_VEC3_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC3_TYPE, A, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_FROM_VEC3_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC4_TYPE, A, B, C)
+#define GLM_SWIZZLE_GEN_VEC4_FROM_VEC4_SWIZZLE(T, P, A, B, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, D, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, D, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, D, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, D, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, D, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, D, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, D, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, D, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, D, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, D, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, D, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, D, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, D, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, D, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, D, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, D, D)
 
-#define GLM_SWIZZLE_GEN_VEC_FROM_VEC3(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE) \
-	GLM_SWIZZLE_GEN_VEC_FROM_VEC3_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, x, y, z) \
-	GLM_SWIZZLE_GEN_VEC_FROM_VEC3_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, r, g, b) \
-	GLM_SWIZZLE_GEN_VEC_FROM_VEC3_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, s, t, p)
+#define GLM_SWIZZLE_GEN_VEC_FROM_VEC4_COMP(T, P, A, B, C, D) \
+	GLM_SWIZZLE_GEN_VEC2_FROM_VEC4_SWIZZLE(T, P, A, B, C, D) \
+	GLM_SWIZZLE_GEN_VEC3_FROM_VEC4_SWIZZLE(T, P, A, B, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_FROM_VEC4_SWIZZLE(T, P, A, B, C, D)
 
-//GLM_SWIZZLE_GEN_VEC_FROM_VEC3(valType, detail::vec3, detail::vec2, detail::vec3, detail::vec4)
+#define GLM_SWIZZLE_GEN_VEC_FROM_VEC4(T, P) \
+	GLM_SWIZZLE_GEN_VEC_FROM_VEC4_COMP(T, P, x, y, z, w) \
+	GLM_SWIZZLE_GEN_VEC_FROM_VEC4_COMP(T, P, r, g, b, a) \
+	GLM_SWIZZLE_GEN_VEC_FROM_VEC4_COMP(T, P, s, t, p, q)
 
-#define GLM_SWIZZLE_GEN_VEC2_FROM_VEC4_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B, C, D) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D)
-
-#define GLM_SWIZZLE_GEN_VEC3_FROM_VEC4_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B, C, D) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, D) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, D) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, D) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, D) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, D) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, D) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, D) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, D) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, D) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, D) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, D) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, D) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, D) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, D) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, D) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, D)
-
-#define GLM_SWIZZLE_GEN_VEC4_FROM_VEC4_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B, C, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, C, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, D, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, D, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, D, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, D, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, C, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, D, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, D, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, D, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, D, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, A, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, B, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, C, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, D, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, D, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, D, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, D, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, A, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, B, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, C, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, D, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, D, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, D, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, D, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, C, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, D, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, D, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, D, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, D, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, C, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, D, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, D, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, D, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, D, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, A, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, B, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, C, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, D, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, D, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, D, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, D, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, A, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, B, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, C, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, D, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, D, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, D, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, D, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, A, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, B, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, C, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, D, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, D, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, D, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, D, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, A, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, B, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, C, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, D, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, D, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, D, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, D, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, A, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, B, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, C, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, D, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, D, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, D, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, D, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, A, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, B, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, C, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, D, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, D, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, D, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, D, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, A, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, B, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, C, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, D, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, D, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, D, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, D, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, A, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, B, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, C, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, D, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, D, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, D, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, D, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, A, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, B, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, C, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, D, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, D, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, D, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, D, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, A, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, B, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, C, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, D, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, D, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, D, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, D, D)
-
-#define GLM_SWIZZLE_GEN_VEC_FROM_VEC4_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, A, B, C, D) \
-	GLM_SWIZZLE_GEN_VEC2_FROM_VEC4_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, A, B, C, D) \
-	GLM_SWIZZLE_GEN_VEC3_FROM_VEC4_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC3_TYPE, A, B, C, D) \
-	GLM_SWIZZLE_GEN_VEC4_FROM_VEC4_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC4_TYPE, A, B, C, D)
-
-#define GLM_SWIZZLE_GEN_VEC_FROM_VEC4(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE) \
-	GLM_SWIZZLE_GEN_VEC_FROM_VEC4_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, x, y, z, w) \
-	GLM_SWIZZLE_GEN_VEC_FROM_VEC4_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, r, g, b, a) \
-	GLM_SWIZZLE_GEN_VEC_FROM_VEC4_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, s, t, p, q)
-
-//GLM_SWIZZLE_GEN_VEC_FROM_VEC4(valType, detail::vec4, detail::vec2, detail::vec3, detail::vec4)
diff --git a/glm/detail/_vectorize.hpp b/glm/detail/_vectorize.hpp
index a08ed34d..44fb0b5d 100644
--- a/glm/detail/_vectorize.hpp
+++ b/glm/detail/_vectorize.hpp
@@ -11,120 +11,120 @@
 namespace glm{
 namespace detail
 {
-	template <typename R, typename T, precision P, template <typename, precision> class vecType>
+	template<length_t L, typename R, typename T, precision P>
 	struct functor1{};
 
-	template <typename R, typename T, precision P>
-	struct functor1<R, T, P, tvec1>
+	template<typename R, typename T, precision P>
+	struct functor1<1, R, T, P>
 	{
-		GLM_FUNC_QUALIFIER static tvec1<R, P> call(R (*Func) (T x), tvec1<T, P> const & v)
+		GLM_FUNC_QUALIFIER static vec<1, R, P> call(R (*Func) (T x), vec<1, T, P> const & v)
 		{
-			return tvec1<R, P>(Func(v.x));
+			return vec<1, R, P>(Func(v.x));
 		}
 	};
 
-	template <typename R, typename T, precision P>
-	struct functor1<R, T, P, tvec2>
+	template<typename R, typename T, precision P>
+	struct functor1<2, R, T, P>
 	{
-		GLM_FUNC_QUALIFIER static tvec2<R, P> call(R (*Func) (T x), tvec2<T, P> const & v)
+		GLM_FUNC_QUALIFIER static vec<2, R, P> call(R (*Func) (T x), vec<2, T, P> const & v)
 		{
-			return tvec2<R, P>(Func(v.x), Func(v.y));
+			return vec<2, R, P>(Func(v.x), Func(v.y));
 		}
 	};
 
-	template <typename R, typename T, precision P>
-	struct functor1<R, T, P, tvec3>
+	template<typename R, typename T, precision P>
+	struct functor1<3, R, T, P>
 	{
-		GLM_FUNC_QUALIFIER static tvec3<R, P> call(R (*Func) (T x), tvec3<T, P> const & v)
+		GLM_FUNC_QUALIFIER static vec<3, R, P> call(R (*Func) (T x), vec<3, T, P> const & v)
 		{
-			return tvec3<R, P>(Func(v.x), Func(v.y), Func(v.z));
+			return vec<3, R, P>(Func(v.x), Func(v.y), Func(v.z));
 		}
 	};
 
-	template <typename R, typename T, precision P>
-	struct functor1<R, T, P, tvec4>
+	template<typename R, typename T, precision P>
+	struct functor1<4, R, T, P>
 	{
-		GLM_FUNC_QUALIFIER static tvec4<R, P> call(R (*Func) (T x), tvec4<T, P> const & v)
+		GLM_FUNC_QUALIFIER static vec<4, R, P> call(R (*Func) (T x), vec<4, T, P> const & v)
 		{
-			return tvec4<R, P>(Func(v.x), Func(v.y), Func(v.z), Func(v.w));
+			return vec<4, R, P>(Func(v.x), Func(v.y), Func(v.z), Func(v.w));
 		}
 	};
 
-	template <typename T, precision P, template <typename, precision> class vecType>
+	template<length_t L, typename T, precision P>
 	struct functor2{};
 
-	template <typename T, precision P>
-	struct functor2<T, P, tvec1>
+	template<typename T, precision P>
+	struct functor2<1, T, P>
 	{
-		GLM_FUNC_QUALIFIER static tvec1<T, P> call(T (*Func) (T x, T y), tvec1<T, P> const & a, tvec1<T, P> const & b)
+		GLM_FUNC_QUALIFIER static vec<1, T, P> call(T (*Func) (T x, T y), vec<1, T, P> const & a, vec<1, T, P> const & b)
 		{
-			return tvec1<T, P>(Func(a.x, b.x));
+			return vec<1, T, P>(Func(a.x, b.x));
 		}
 	};
 
-	template <typename T, precision P>
-	struct functor2<T, P, tvec2>
+	template<typename T, precision P>
+	struct functor2<2, T, P>
 	{
-		GLM_FUNC_QUALIFIER static tvec2<T, P> call(T (*Func) (T x, T y), tvec2<T, P> const & a, tvec2<T, P> const & b)
+		GLM_FUNC_QUALIFIER static vec<2, T, P> call(T (*Func) (T x, T y), vec<2, T, P> const & a, vec<2, T, P> const & b)
 		{
-			return tvec2<T, P>(Func(a.x, b.x), Func(a.y, b.y));
+			return vec<2, T, P>(Func(a.x, b.x), Func(a.y, b.y));
 		}
 	};
 
-	template <typename T, precision P>
-	struct functor2<T, P, tvec3>
+	template<typename T, precision P>
+	struct functor2<3, T, P>
 	{
-		GLM_FUNC_QUALIFIER static tvec3<T, P> call(T (*Func) (T x, T y), tvec3<T, P> const & a, tvec3<T, P> const & b)
+		GLM_FUNC_QUALIFIER static vec<3, T, P> call(T (*Func) (T x, T y), vec<3, T, P> const & a, vec<3, T, P> const & b)
 		{
-			return tvec3<T, P>(Func(a.x, b.x), Func(a.y, b.y), Func(a.z, b.z));
+			return vec<3, T, P>(Func(a.x, b.x), Func(a.y, b.y), Func(a.z, b.z));
 		}
 	};
 
-	template <typename T, precision P>
-	struct functor2<T, P, tvec4>
+	template<typename T, precision P>
+	struct functor2<4, T, P>
 	{
-		GLM_FUNC_QUALIFIER static tvec4<T, P> call(T (*Func) (T x, T y), tvec4<T, P> const & a, tvec4<T, P> const & b)
+		GLM_FUNC_QUALIFIER static vec<4, T, P> call(T (*Func) (T x, T y), vec<4, T, P> const & a, vec<4, T, P> const & b)
 		{
-			return tvec4<T, P>(Func(a.x, b.x), Func(a.y, b.y), Func(a.z, b.z), Func(a.w, b.w));
+			return vec<4, T, P>(Func(a.x, b.x), Func(a.y, b.y), Func(a.z, b.z), Func(a.w, b.w));
 		}
 	};
 
-	template <typename T, precision P, template <typename, precision> class vecType>
+	template<length_t L, typename T, precision P>
 	struct functor2_vec_sca{};
 
-	template <typename T, precision P>
-	struct functor2_vec_sca<T, P, tvec1>
+	template<typename T, precision P>
+	struct functor2_vec_sca<1, T, P>
 	{
-		GLM_FUNC_QUALIFIER static tvec1<T, P> call(T (*Func) (T x, T y), tvec1<T, P> const & a, T b)
+		GLM_FUNC_QUALIFIER static vec<1, T, P> call(T (*Func) (T x, T y), vec<1, T, P> const & a, T b)
 		{
-			return tvec1<T, P>(Func(a.x, b));
+			return vec<1, T, P>(Func(a.x, b));
 		}
 	};
 
-	template <typename T, precision P>
-	struct functor2_vec_sca<T, P, tvec2>
+	template<typename T, precision P>
+	struct functor2_vec_sca<2, T, P>
 	{
-		GLM_FUNC_QUALIFIER static tvec2<T, P> call(T (*Func) (T x, T y), tvec2<T, P> const & a, T b)
+		GLM_FUNC_QUALIFIER static vec<2, T, P> call(T (*Func) (T x, T y), vec<2, T, P> const & a, T b)
 		{
-			return tvec2<T, P>(Func(a.x, b), Func(a.y, b));
+			return vec<2, T, P>(Func(a.x, b), Func(a.y, b));
 		}
 	};
 
-	template <typename T, precision P>
-	struct functor2_vec_sca<T, P, tvec3>
+	template<typename T, precision P>
+	struct functor2_vec_sca<3, T, P>
 	{
-		GLM_FUNC_QUALIFIER static tvec3<T, P> call(T (*Func) (T x, T y), tvec3<T, P> const & a, T b)
+		GLM_FUNC_QUALIFIER static vec<3, T, P> call(T (*Func) (T x, T y), vec<3, T, P> const & a, T b)
 		{
-			return tvec3<T, P>(Func(a.x, b), Func(a.y, b), Func(a.z, b));
+			return vec<3, T, P>(Func(a.x, b), Func(a.y, b), Func(a.z, b));
 		}
 	};
 
-	template <typename T, precision P>
-	struct functor2_vec_sca<T, P, tvec4>
+	template<typename T, precision P>
+	struct functor2_vec_sca<4, T, P>
 	{
-		GLM_FUNC_QUALIFIER static tvec4<T, P> call(T (*Func) (T x, T y), tvec4<T, P> const & a, T b)
+		GLM_FUNC_QUALIFIER static vec<4, T, P> call(T (*Func) (T x, T y), vec<4, T, P> const & a, T b)
 		{
-			return tvec4<T, P>(Func(a.x, b), Func(a.y, b), Func(a.z, b), Func(a.w, b));
+			return vec<4, T, P>(Func(a.x, b), Func(a.y, b), Func(a.z, b), Func(a.w, b));
 		}
 	};
 }//namespace detail
diff --git a/glm/detail/dummy.cpp b/glm/detail/dummy.cpp
index a519a6dc..fb1daf38 100644
--- a/glm/detail/dummy.cpp
+++ b/glm/detail/dummy.cpp
@@ -166,21 +166,21 @@ glm::vec3 lighting
 */
 
 /*
-template <typename T, glm::precision P, template<typename, glm::precision> class vecType>
-T normalizeDotA(vecType<T, P> const & x, vecType<T, P> const & y)
+template<typename T, glm::precision P, template<typename, glm::precision> class vecType>
+T normalizeDotA(vecType<L, T, P> const & x, vecType<L, T, P> const & y)
 {
 	return glm::dot(x, y) * glm::inversesqrt(glm::dot(x, x) * glm::dot(y, y));
 }
 
 #define GLM_TEMPLATE_GENTYPE typename T, glm::precision P, template<typename, glm::precision> class
 
-template <GLM_TEMPLATE_GENTYPE vecType>
-T normalizeDotB(vecType<T, P> const & x, vecType<T, P> const & y)
+template<GLM_TEMPLATE_GENTYPE vecType>
+T normalizeDotB(vecType<L, T, P> const & x, vecType<L, T, P> const & y)
 {
 	return glm::dot(x, y) * glm::inversesqrt(glm::dot(x, x) * glm::dot(y, y));
 }
 
-template <typename vecType>
+template<typename vecType>
 typename vecType::value_type normalizeDotC(vecType const & a, vecType const & b)
 {
 	return glm::dot(a, b) * glm::inversesqrt(glm::dot(a, a) * glm::dot(b, b));
diff --git a/glm/detail/func_common.hpp b/glm/detail/func_common.hpp
index 871fed6c..97326ca2 100644
--- a/glm/detail/func_common.hpp
+++ b/glm/detail/func_common.hpp
@@ -26,11 +26,11 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/abs.xml">GLSL abs man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL genType abs(genType x);
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> abs(vecType<T, P> const & x);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, T, P> abs(vecType<L, T, P> const & x);
 
 	/// Returns 1.0 if x > 0, 0.0 if x == 0, or -1.0 if x < 0. 
 	/// 
@@ -38,8 +38,8 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/sign.xml">GLSL sign man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> sign(vecType<T, P> const & x);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, T, P> sign(vecType<L, T, P> const & x);
 
 	/// Returns a value equal to the nearest integer that is less then or equal to x. 
 	/// 
@@ -47,8 +47,8 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/floor.xml">GLSL floor man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> floor(vecType<T, P> const & x);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, T, P> floor(vecType<L, T, P> const & x);
 
 	/// Returns a value equal to the nearest integer to x
 	/// whose absolute value is not larger than the absolute value of x.
@@ -57,8 +57,8 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/trunc.xml">GLSL trunc man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> trunc(vecType<T, P> const & x);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, T, P> trunc(vecType<L, T, P> const & x);
 
 	/// Returns a value equal to the nearest integer to x.
 	/// The fraction 0.5 will round in a direction chosen by the
@@ -70,8 +70,8 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/round.xml">GLSL round man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> round(vecType<T, P> const & x);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, T, P> round(vecType<L, T, P> const & x);
 
 	/// Returns a value equal to the nearest integer to x.
 	/// A fractional part of 0.5 will round toward the nearest even
@@ -82,8 +82,8 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/roundEven.xml">GLSL roundEven man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
 	/// @see <a href="http://developer.amd.com/documentation/articles/pages/New-Round-to-Even-Technique.aspx">New round to even technique</a>
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> roundEven(vecType<T, P> const & x);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, T, P> roundEven(vecType<L, T, P> const & x);
 
 	/// Returns a value equal to the nearest integer
 	/// that is greater than or equal to x.
@@ -92,8 +92,8 @@ namespace glm
 	///
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/ceil.xml">GLSL ceil man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> ceil(vecType<T, P> const & x);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, T, P> ceil(vecType<L, T, P> const & x);
 
 	/// Return x - floor(x).
 	/// 
@@ -101,11 +101,11 @@ namespace glm
 	///
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/fract.xml">GLSL fract man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL genType fract(genType x);
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> fract(vecType<T, P> const & x);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, T, P> fract(vecType<L, T, P> const & x);
 
 	/// Modulus. Returns x - y * floor(x / y)
 	/// for each component in x using the floating point value y.
@@ -114,14 +114,14 @@ namespace glm
 	///
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/mod.xml">GLSL mod man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL genType mod(genType x, genType y);
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> mod(vecType<T, P> const & x, T y);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, T, P> mod(vecType<L, T, P> const & x, T y);
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> mod(vecType<T, P> const & x, vecType<T, P> const & y);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, T, P> mod(vecType<L, T, P> const & x, vecType<L, T, P> const & y);
 
 	/// Returns the fractional part of x and sets i to the integer
 	/// part (as a whole number floating point value). Both the
@@ -132,7 +132,7 @@ namespace glm
 	///
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/modf.xml">GLSL modf man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL genType modf(genType x, genType & i);
 
 	/// Returns y if y < x; otherwise, it returns x.
@@ -141,14 +141,14 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/min.xml">GLSL min man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL genType min(genType x, genType y);
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> min(vecType<T, P> const & x, T y);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, T, P> min(vecType<L, T, P> const & x, T y);
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> min(vecType<T, P> const & x, vecType<T, P> const & y);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, T, P> min(vecType<L, T, P> const & x, vecType<L, T, P> const & y);
 
 	/// Returns y if x < y; otherwise, it returns x.
 	/// 
@@ -156,14 +156,14 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/max.xml">GLSL max man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL genType max(genType x, genType y);
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> max(vecType<T, P> const & x, T y);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, T, P> max(vecType<L, T, P> const & x, T y);
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> max(vecType<T, P> const & x, vecType<T, P> const & y);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, T, P> max(vecType<L, T, P> const & x, vecType<L, T, P> const & y);
 
 	/// Returns min(max(x, minVal), maxVal) for each component in x 
 	/// using the floating-point values minVal and maxVal.
@@ -172,14 +172,14 @@ namespace glm
 	///
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/clamp.xml">GLSL clamp man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL genType clamp(genType x, genType minVal, genType maxVal);
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> clamp(vecType<T, P> const & x, T minVal, T maxVal);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, T, P> clamp(vecType<L, T, P> const & x, T minVal, T maxVal);
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> clamp(vecType<T, P> const & x, vecType<T, P> const & minVal, vecType<T, P> const & maxVal);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, T, P> clamp(vecType<L, T, P> const & x, vecType<L, T, P> const & minVal, vecType<L, T, P> const & maxVal);
 
 	/// If genTypeU is a floating scalar or vector:
 	/// Returns x * (1.0 - a) + y * a, i.e., the linear blend of
@@ -223,35 +223,35 @@ namespace glm
 	/// glm::dvec3 t = glm::mix(e, f, a); // Types of the third parameter is not required to match with the first and the second.
 	/// glm::vec4 u = glm::mix(g, h, r); // Interpolations can be perform per component with a vector for the last parameter.
 	/// @endcode
-	template <typename T, typename U, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> mix(vecType<T, P> const & x, vecType<T, P> const & y, vecType<U, P> const & a);
+	template<length_t L, typename T, typename U, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, T, P> mix(vecType<L, T, P> const & x, vecType<L, T, P> const & y, vecType<L, U, P> const & a);
 
-	template <typename T, typename U, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> mix(vecType<T, P> const & x, vecType<T, P> const & y, U a);
+	template<length_t L, typename T, typename U, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, T, P> mix(vecType<L, T, P> const & x, vecType<L, T, P> const & y, U a);
 
-	template <typename genTypeT, typename genTypeU>
+	template<typename genTypeT, typename genTypeU>
 	GLM_FUNC_DECL genTypeT mix(genTypeT x, genTypeT y, genTypeU a);
 
 	/// Returns 0.0 if x < edge, otherwise it returns 1.0 for each component of a genType.
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/step.xml">GLSL step man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL genType step(genType edge, genType x);
 
 	/// Returns 0.0 if x < edge, otherwise it returns 1.0.
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/step.xml">GLSL step man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
-	template <template <typename, precision> class vecType, typename T, precision P>
-	GLM_FUNC_DECL vecType<T, P> step(T edge, vecType<T, P> const & x);
+	template<template<length_t, typename, precision> class vecType, length_t L, typename T, precision P>
+	GLM_FUNC_DECL vecType<L, T, P> step(T edge, vecType<L, T, P> const & x);
 
 	/// Returns 0.0 if x < edge, otherwise it returns 1.0.
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/step.xml">GLSL step man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
-	template <template <typename, precision> class vecType, typename T, precision P>
-	GLM_FUNC_DECL vecType<T, P> step(vecType<T, P> const & edge, vecType<T, P> const & x);
+	template<template<length_t, typename, precision> class vecType, length_t L, typename T, precision P>
+	GLM_FUNC_DECL vecType<L, T, P> step(vecType<L, T, P> const & edge, vecType<L, T, P> const & x);
 
 	/// Returns 0.0 if x <= edge0 and 1.0 if x >= edge1 and
 	/// performs smooth Hermite interpolation between 0 and 1
@@ -267,14 +267,14 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/smoothstep.xml">GLSL smoothstep man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL genType smoothstep(genType edge0, genType edge1, genType x);
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> smoothstep(T edge0, T edge1, vecType<T, P> const & x);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, T, P> smoothstep(T edge0, T edge1, vecType<L, T, P> const & x);
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> smoothstep(vecType<T, P> const & edge0, vecType<T, P> const & edge1, vecType<T, P> const & x);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, T, P> smoothstep(vecType<L, T, P> const & edge0, vecType<L, T, P> const & edge1, vecType<L, T, P> const & x);
 
 	/// Returns true if x holds a NaN (not a number)
 	/// representation in the underlying implementation's set of
@@ -288,8 +288,8 @@ namespace glm
 	///
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/isnan.xml">GLSL isnan man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<bool, P> isnan(vecType<T, P> const & x);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, bool, P> isnan(vecType<L, T, P> const & x);
 
 	/// Returns true if x holds a positive infinity or negative
 	/// infinity representation in the underlying implementation's
@@ -301,8 +301,8 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/isinf.xml">GLSL isinf man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<bool, P> isinf(vecType<T, P> const & x);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, bool, P> isinf(vecType<L, T, P> const & x);
 
 	/// Returns a signed integer value representing
 	/// the encoding of a floating-point value. The floating-point
@@ -318,8 +318,8 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/floatBitsToInt.xml">GLSL floatBitsToInt man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
-	template <template <typename, precision> class vecType, precision P>
-	GLM_FUNC_DECL vecType<int, P> floatBitsToInt(vecType<float, P> const & v);
+	template<template<length_t, typename, precision> class vecType, length_t L, precision P>
+	GLM_FUNC_DECL vecType<L, int, P> floatBitsToInt(vecType<L, float, P> const & v);
 
 	/// Returns a unsigned integer value representing
 	/// the encoding of a floating-point value. The floatingpoint
@@ -335,8 +335,8 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/floatBitsToUint.xml">GLSL floatBitsToUint man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
-	template <template <typename, precision> class vecType, precision P>
-	GLM_FUNC_DECL vecType<uint, P> floatBitsToUint(vecType<float, P> const & v);
+	template<template<length_t, typename, precision> class vecType, length_t L, precision P>
+	GLM_FUNC_DECL vecType<L, uint, P> floatBitsToUint(vecType<L, float, P> const & v);
 
 	/// Returns a floating-point value corresponding to a signed
 	/// integer encoding of a floating-point value.
@@ -356,8 +356,8 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/intBitsToFloat.xml">GLSL intBitsToFloat man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
-	template <template <typename, precision> class vecType, precision P>
-	GLM_FUNC_DECL vecType<float, P> intBitsToFloat(vecType<int, P> const & v);
+	template<template<length_t, typename, precision> class vecType, length_t L, precision P>
+	GLM_FUNC_DECL vecType<L, float, P> intBitsToFloat(vecType<L, int, P> const & v);
 
 	/// Returns a floating-point value corresponding to a
 	/// unsigned integer encoding of a floating-point value.
@@ -377,8 +377,8 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/uintBitsToFloat.xml">GLSL uintBitsToFloat man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
-	template <template <typename, precision> class vecType, precision P>
-	GLM_FUNC_DECL vecType<float, P> uintBitsToFloat(vecType<uint, P> const & v);
+	template<template<length_t, typename, precision> class vecType, length_t L, precision P>
+	GLM_FUNC_DECL vecType<L, float, P> uintBitsToFloat(vecType<L, uint, P> const & v);
 
 	/// Computes and returns a * b + c.
 	/// 
@@ -386,7 +386,7 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/fma.xml">GLSL fma man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL genType fma(genType const & a, genType const & b, genType const & c);
 
 	/// Splits x into a floating-point significand in the range
@@ -403,7 +403,7 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/frexp.xml">GLSL frexp man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
-	template <typename genType, typename genIType>
+	template<typename genType, typename genIType>
 	GLM_FUNC_DECL genType frexp(genType const & x, genIType & exp);
 
 	/// Builds a floating-point number from x and the
@@ -417,7 +417,7 @@ namespace glm
 	///  
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/ldexp.xml">GLSL ldexp man page</a>; 
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
-	template <typename genType, typename genIType>
+	template<typename genType, typename genIType>
 	GLM_FUNC_DECL genType ldexp(genType const & x, genIType const & exp);
 
 	/// @}
diff --git a/glm/detail/func_common.inl b/glm/detail/func_common.inl
index 327b058a..cafaed59 100644
--- a/glm/detail/func_common.inl
+++ b/glm/detail/func_common.inl
@@ -11,7 +11,7 @@
 namespace glm
 {
 	// min
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER genType min(genType x, genType y)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || std::numeric_limits<genType>::is_integer || GLM_UNRESTRICTED_GENTYPE, "'min' only accept floating-point or integer inputs");
@@ -19,7 +19,7 @@ namespace glm
 	}
 
 	// max
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER genType max(genType x, genType y)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || std::numeric_limits<genType>::is_integer || GLM_UNRESTRICTED_GENTYPE, "'max' only accept floating-point or integer inputs");
@@ -28,7 +28,7 @@ namespace glm
 	}
 
 	// abs
-	template <>
+	template<>
 	GLM_FUNC_QUALIFIER int32 abs(int32 x)
 	{
 		int32 const y = x >> 31;
@@ -39,7 +39,7 @@ namespace glm
 #	if GLM_HAS_CXX11_STL
 		using ::std::round;
 #	else
-		template <typename genType>
+		template<typename genType>
 		GLM_FUNC_QUALIFIER genType round(genType x)
 		{
 			GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'round' only accept floating-point inputs");
@@ -52,7 +52,7 @@ namespace glm
 #	if GLM_HAS_CXX11_STL
 		using ::std::trunc;
 #	else
-		template <typename genType>
+		template<typename genType>
 		GLM_FUNC_QUALIFIER genType trunc(genType x)
 		{
 			GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'trunc' only accept floating-point inputs");
@@ -66,11 +66,11 @@ namespace glm
 namespace glm{
 namespace detail
 {
-	template <typename genFIType, bool /*signed*/>
+	template<typename genFIType, bool /*signed*/>
 	struct compute_abs
 	{};
 
-	template <typename genFIType>
+	template<typename genFIType>
 	struct compute_abs<genFIType, true>
 	{
 		GLM_FUNC_QUALIFIER static genFIType call(genFIType x)
@@ -85,7 +85,7 @@ namespace detail
 	};
 
 	#if GLM_COMPILER & GLM_COMPILER_CUDA
-	template <>
+	template<>
 	struct compute_abs<float, true>
 	{
 		GLM_FUNC_QUALIFIER static float call(float x)
@@ -95,7 +95,7 @@ namespace detail
 	};
 	#endif
 
-	template <typename genFIType>
+	template<typename genFIType>
 	struct compute_abs<genFIType, false>
 	{
 		GLM_FUNC_QUALIFIER static genFIType call(genFIType x)
@@ -107,59 +107,59 @@ namespace detail
 		}
 	};
 
-	template <typename T, precision P, template <typename, precision> class vecType, bool Aligned>
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType, bool Aligned>
 	struct compute_abs_vector
 	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x)
+		GLM_FUNC_QUALIFIER static vecType<L, T, P> call(vecType<L, T, P> const & x)
 		{
-			return detail::functor1<T, T, P, vecType>::call(abs, x);
+			return detail::functor1<L, T, T, P>::call(abs, x);
 		}
 	};
 
-	template <typename T, typename U, precision P, template <typename, precision> class vecType, bool Aligned>
+	template<length_t L, typename T, typename U, precision P, template<length_t, typename, precision> class vecType, bool Aligned>
 	struct compute_mix_vector
 	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x, vecType<T, P> const & y, vecType<U, P> const & a)
+		GLM_FUNC_QUALIFIER static vecType<L, T, P> call(vecType<L, T, P> const & x, vecType<L, T, P> const & y, vecType<L, U, P> const & a)
 		{
 			GLM_STATIC_ASSERT(std::numeric_limits<U>::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'mix' only accept floating-point inputs for the interpolator a");
 
-			return vecType<T, P>(vecType<U, P>(x) + a * vecType<U, P>(y - x));
+			return vecType<L, T, P>(vecType<L, U, P>(x) + a * vecType<L, U, P>(y - x));
 		}
 	};
 
-	template <typename T, precision P, template <typename, precision> class vecType, bool Aligned>
-	struct compute_mix_vector<T, bool, P, vecType, Aligned>
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType, bool Aligned>
+	struct compute_mix_vector<L, T, bool, P, vecType, Aligned>
 	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x, vecType<T, P> const & y, vecType<bool, P> const & a)
+		GLM_FUNC_QUALIFIER static vecType<L, T, P> call(vecType<L, T, P> const & x, vecType<L, T, P> const & y, vecType<L, bool, P> const & a)
 		{
-			vecType<T, P> Result(uninitialize);
+			vecType<L, T, P> Result(uninitialize);
 			for(length_t i = 0; i < x.length(); ++i)
 				Result[i] = a[i] ? y[i] : x[i];
 			return Result;
 		}
 	};
 
-	template <typename T, typename U, precision P, template <typename, precision> class vecType, bool Aligned>
+	template<length_t L, typename T, typename U, precision P, template<length_t, typename, precision> class vecType, bool Aligned>
 	struct compute_mix_scalar
 	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x, vecType<T, P> const & y, U const & a)
+		GLM_FUNC_QUALIFIER static vecType<L, T, P> call(vecType<L, T, P> const & x, vecType<L, T, P> const & y, U const & a)
 		{
 			GLM_STATIC_ASSERT(std::numeric_limits<U>::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'mix' only accept floating-point inputs for the interpolator a");
 
-			return vecType<T, P>(vecType<U, P>(x) + a * vecType<U, P>(y - x));
+			return vecType<L, T, P>(vecType<L, U, P>(x) + a * vecType<L, U, P>(y - x));
 		}
 	};
 
-	template <typename T, precision P, template <typename, precision> class vecType, bool Aligned>
-	struct compute_mix_scalar<T, bool, P, vecType, Aligned>
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType, bool Aligned>
+	struct compute_mix_scalar<L, T, bool, P, vecType, Aligned>
 	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x, vecType<T, P> const & y, bool const & a)
+		GLM_FUNC_QUALIFIER static vecType<L, T, P> call(vecType<L, T, P> const & x, vecType<L, T, P> const & y, bool const & a)
 		{
 			return a ? y : x;
 		}
 	};
 
-	template <typename T, typename U>
+	template<typename T, typename U>
 	struct compute_mix
 	{
 		GLM_FUNC_QUALIFIER static T call(T const & x, T const & y, U const & a)
@@ -170,7 +170,7 @@ namespace detail
 		}
 	};
 
-	template <typename T>
+	template<typename T>
 	struct compute_mix<T, bool>
 	{
 		GLM_FUNC_QUALIFIER static T call(T const & x, T const & y, bool const & a)
@@ -179,192 +179,192 @@ namespace detail
 		}
 	};
 
-	template <typename T, precision P, template <typename, precision> class vecType, bool isFloat, bool Aligned>
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType, bool isFloat, bool Aligned>
 	struct compute_sign
 	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x)
+		GLM_FUNC_QUALIFIER static vecType<L, T, P> call(vecType<L, T, P> const & x)
 		{
-			return vecType<T, P>(glm::lessThan(vecType<T, P>(0), x)) - vecType<T, P>(glm::lessThan(x, vecType<T, P>(0)));
+			return vecType<L, T, P>(glm::lessThan(vecType<L, T, P>(0), x)) - vecType<L, T, P>(glm::lessThan(x, vecType<L, T, P>(0)));
 		}
 	};
 
 #	if GLM_ARCH == GLM_ARCH_X86
-	template <typename T, precision P, template <typename, precision> class vecType, bool Aligned>
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType, bool Aligned>
 	struct compute_sign<T, P, vecType, false, Aligned>
 	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x)
+		GLM_FUNC_QUALIFIER static vecType<L, T, P> call(vecType<L, T, P> const & x)
 		{
 			T const Shift(static_cast<T>(sizeof(T) * 8 - 1));
-			vecType<T, P> const y(vecType<typename make_unsigned<T>::type, P>(-x) >> typename make_unsigned<T>::type(Shift));
+			vecType<L, T, P> const y(vecType<typename make_unsigned<T>::type, P>(-x) >> typename make_unsigned<T>::type(Shift));
 
 			return (x >> Shift) | y;
 		}
 	};
 #	endif
 
-	template <typename T, precision P, template <typename, precision> class vecType, bool Aligned>
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType, bool Aligned>
 	struct compute_floor
 	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x)
+		GLM_FUNC_QUALIFIER static vecType<L, T, P> call(vecType<L, T, P> const & x)
 		{
-			return detail::functor1<T, T, P, vecType>::call(std::floor, x);
+			return detail::functor1<L, T, T, P>::call(std::floor, x);
 		}
 	};
 
-	template <typename T, precision P, template <typename, precision> class vecType, bool Aligned>
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType, bool Aligned>
 	struct compute_ceil
 	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x)
+		GLM_FUNC_QUALIFIER static vecType<L, T, P> call(vecType<L, T, P> const & x)
 		{
-			return detail::functor1<T, T, P, vecType>::call(std::ceil, x);
+			return detail::functor1<L, T, T, P>::call(std::ceil, x);
 		}
 	};
 
-	template <typename T, precision P, template <typename, precision> class vecType, bool Aligned>
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType, bool Aligned>
 	struct compute_fract
 	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x)
+		GLM_FUNC_QUALIFIER static vecType<L, T, P> call(vecType<L, T, P> const & x)
 		{
 			return x - floor(x);
 		}
 	};
 
-	template <typename T, precision P, template <typename, precision> class vecType, bool Aligned>
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType, bool Aligned>
 	struct compute_trunc
 	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x)
+		GLM_FUNC_QUALIFIER static vecType<L, T, P> call(vecType<L, T, P> const & x)
 		{
-			return detail::functor1<T, T, P, vecType>::call(trunc, x);
+			return detail::functor1<L, T, T, P>::call(trunc, x);
 		}
 	};
 
-	template <typename T, precision P, template <typename, precision> class vecType, bool Aligned>
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType, bool Aligned>
 	struct compute_round
 	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x)
+		GLM_FUNC_QUALIFIER static vecType<L, T, P> call(vecType<L, T, P> const & x)
 		{
-			return detail::functor1<T, T, P, vecType>::call(round, x);
+			return detail::functor1<L, T, T, P>::call(round, x);
 		}
 	};
 
-	template <typename T, precision P, template <typename, precision> class vecType, bool Aligned>
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType, bool Aligned>
 	struct compute_mod
 	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & a, vecType<T, P> const & b)
+		GLM_FUNC_QUALIFIER static vecType<L, T, P> call(vecType<L, T, P> const & a, vecType<L, T, P> const & b)
 		{
 			GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'mod' only accept floating-point inputs. Include <glm/gtc/integer.hpp> for integer inputs.");
 			return a - b * floor(a / b);
 		}
 	};
 
-	template <typename T, precision P, template <typename, precision> class vecType, bool Aligned>
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType, bool Aligned>
 	struct compute_min_vector
 	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x, vecType<T, P> const & y)
+		GLM_FUNC_QUALIFIER static vecType<L, T, P> call(vecType<L, T, P> const & x, vecType<L, T, P> const & y)
 		{
-			return detail::functor2<T, P, vecType>::call(min, x, y);
+			return detail::functor2<L, T, P>::call(min, x, y);
 		}
 	};
 
-	template <typename T, precision P, template <typename, precision> class vecType, bool Aligned>
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType, bool Aligned>
 	struct compute_max_vector
 	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x, vecType<T, P> const & y)
+		GLM_FUNC_QUALIFIER static vecType<L, T, P> call(vecType<L, T, P> const & x, vecType<L, T, P> const & y)
 		{
-			return detail::functor2<T, P, vecType>::call(max, x, y);
+			return detail::functor2<L, T, P>::call(max, x, y);
 		}
 	};
 
-	template <typename T, precision P, template <typename, precision> class vecType, bool Aligned>
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType, bool Aligned>
 	struct compute_clamp_vector
 	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x, vecType<T, P> const & minVal, vecType<T, P> const & maxVal)
+		GLM_FUNC_QUALIFIER static vecType<L, T, P> call(vecType<L, T, P> const & x, vecType<L, T, P> const & minVal, vecType<L, T, P> const & maxVal)
 		{
 			return min(max(x, minVal), maxVal);
 		}
 	};
 
-	template <typename T, precision P, template <typename, precision> class vecType, bool Aligned>
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType, bool Aligned>
 	struct compute_step_vector
 	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & edge, vecType<T, P> const & x)
+		GLM_FUNC_QUALIFIER static vecType<L, T, P> call(vecType<L, T, P> const & edge, vecType<L, T, P> const & x)
 		{
-			return mix(vecType<T, P>(1), vecType<T, P>(0), glm::lessThan(x, edge));
+			return mix(vecType<L, T, P>(1), vecType<L, T, P>(0), glm::lessThan(x, edge));
 		}
 	};
 
-	template <typename T, precision P, template <typename, precision> class vecType, bool Aligned>
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType, bool Aligned>
 	struct compute_smoothstep_vector
 	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & edge0, vecType<T, P> const & edge1, vecType<T, P> const & x)
+		GLM_FUNC_QUALIFIER static vecType<L, T, P> call(vecType<L, T, P> const & edge0, vecType<L, T, P> const & edge1, vecType<L, T, P> const & x)
 		{
 			GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'step' only accept floating-point inputs");
-			vecType<T, P> const tmp(clamp((x - edge0) / (edge1 - edge0), static_cast<T>(0), static_cast<T>(1)));
+			vecType<L, T, P> const tmp(clamp((x - edge0) / (edge1 - edge0), static_cast<T>(0), static_cast<T>(1)));
 			return tmp * tmp * (static_cast<T>(3) - static_cast<T>(2) * tmp);
 		}
 	};
 }//namespace detail
 
-	template <typename genFIType>
+	template<typename genFIType>
 	GLM_FUNC_QUALIFIER genFIType abs(genFIType x)
 	{
 		return detail::compute_abs<genFIType, std::numeric_limits<genFIType>::is_signed>::call(x);
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> abs(vecType<T, P> const & x)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> abs(vecType<L, T, P> const & x)
 	{
-		return detail::compute_abs_vector<T, P, vecType, detail::is_aligned<P>::value>::call(x);
+		return detail::compute_abs_vector<L, T, P, vecType, detail::is_aligned<P>::value>::call(x);
 	}
 
 	// sign
 	// fast and works for any type
-	template <typename genFIType> 
+	template<typename genFIType> 
 	GLM_FUNC_QUALIFIER genFIType sign(genFIType x)
 	{
 		GLM_STATIC_ASSERT(
 			std::numeric_limits<genFIType>::is_iec559 || (std::numeric_limits<genFIType>::is_signed && std::numeric_limits<genFIType>::is_integer),
 			"'sign' only accept signed inputs");
 		
-		return detail::compute_sign<genFIType, defaultp, tvec1, std::numeric_limits<genFIType>::is_iec559, highp>::call(tvec1<genFIType>(x)).x;
+		return detail::compute_sign<1, genFIType, defaultp, vec, std::numeric_limits<genFIType>::is_iec559, highp>::call(vec<1, genFIType>(x)).x;
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> sign(vecType<T, P> const & x)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> sign(vecType<L, T, P> const & x)
 	{
 		GLM_STATIC_ASSERT(
 			std::numeric_limits<T>::is_iec559 || (std::numeric_limits<T>::is_signed && std::numeric_limits<T>::is_integer),
 			"'sign' only accept signed inputs");
 
-		return detail::compute_sign<T, P, vecType, std::numeric_limits<T>::is_iec559, detail::is_aligned<P>::value>::call(x);
+		return detail::compute_sign<L, T, P, vecType, std::numeric_limits<T>::is_iec559, detail::is_aligned<P>::value>::call(x);
 	}
 
 	// floor
 	using ::std::floor;
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> floor(vecType<T, P> const & x)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> floor(vecType<L, T, P> const & x)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'floor' only accept floating-point inputs.");
-		return detail::compute_floor<T, P, vecType, detail::is_aligned<P>::value>::call(x);
+		return detail::compute_floor<L, T, P, vecType, detail::is_aligned<P>::value>::call(x);
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> trunc(vecType<T, P> const & x)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> trunc(vecType<L, T, P> const & x)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'trunc' only accept floating-point inputs");
-		return detail::compute_trunc<T, P, vecType, detail::is_aligned<P>::value>::call(x);
+		return detail::compute_trunc<L, T, P, vecType, detail::is_aligned<P>::value>::call(x);
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> round(vecType<T, P> const & x)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> round(vecType<L, T, P> const & x)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'round' only accept floating-point inputs");
-		return detail::compute_round<T, P, vecType, detail::is_aligned<P>::value>::call(x);
+		return detail::compute_round<L, T, P, vecType, detail::is_aligned<P>::value>::call(x);
 	}
 
 /*
 	// roundEven
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER genType roundEven(genType const& x)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'roundEven' only accept floating-point inputs");
@@ -374,7 +374,7 @@ namespace detail
 */
 
 	// roundEven
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER genType roundEven(genType x)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'roundEven' only accept floating-point inputs");
@@ -405,97 +405,97 @@ namespace detail
 		//}
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> roundEven(vecType<T, P> const & x)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> roundEven(vecType<L, T, P> const & x)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'roundEven' only accept floating-point inputs");
-		return detail::functor1<T, T, P, vecType>::call(roundEven, x);
+		return detail::functor1<L, T, T, P>::call(roundEven, x);
 	}
 
 	// ceil
 	using ::std::ceil;
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> ceil(vecType<T, P> const & x)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> ceil(vecType<L, T, P> const & x)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'ceil' only accept floating-point inputs");
-		return detail::compute_ceil<T, P, vecType, detail::is_aligned<P>::value>::call(x);
+		return detail::compute_ceil<L, T, P, vecType, detail::is_aligned<P>::value>::call(x);
 	}
 
 	// fract
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER genType fract(genType x)
 	{
-		return fract(tvec1<genType>(x)).x;
+		return fract(vec<1, genType>(x)).x;
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> fract(vecType<T, P> const & x)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> fract(vecType<L, T, P> const & x)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'fract' only accept floating-point inputs");
-		return detail::compute_fract<T, P, vecType, detail::is_aligned<P>::value>::call(x);
+		return detail::compute_fract<L, T, P, vecType, detail::is_aligned<P>::value>::call(x);
 	}
 
 	// mod
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER genType mod(genType x, genType y)
 	{
 #		if GLM_COMPILER & GLM_COMPILER_CUDA
 			// Another Cuda compiler bug https://github.com/g-truc/glm/issues/530
-			tvec1<genType, defaultp> Result(mod(tvec1<genType, defaultp>(x), y));
+			vec<1, genType, defaultp> Result(mod(vec<1, genType, defaultp>(x), y));
 			return Result.x;
 #		else
-			return mod(tvec1<genType, defaultp>(x), y).x;
+			return mod(vec<1, genType, defaultp>(x), y).x;
 #		endif
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> mod(vecType<T, P> const & x, T y)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> mod(vecType<L, T, P> const & x, T y)
 	{
-		return detail::compute_mod<T, P, vecType, detail::is_aligned<P>::value>::call(x, vecType<T, P>(y));
+		return detail::compute_mod<L, T, P, vecType, detail::is_aligned<P>::value>::call(x, vecType<L, T, P>(y));
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> mod(vecType<T, P> const & x, vecType<T, P> const & y)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> mod(vecType<L, T, P> const & x, vecType<L, T, P> const & y)
 	{
-		return detail::compute_mod<T, P, vecType, detail::is_aligned<P>::value>::call(x, y);
+		return detail::compute_mod<L, T, P, vecType, detail::is_aligned<P>::value>::call(x, y);
 	}
 
 	// modf
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER genType modf(genType x, genType & i)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'modf' only accept floating-point inputs");
 		return std::modf(x, &i);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec1<T, P> modf(tvec1<T, P> const & x, tvec1<T, P> & i)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<1, T, P> modf(vec<1, T, P> const & x, vec<1, T, P> & i)
 	{
-		return tvec1<T, P>(
+		return vec<1, T, P>(
 			modf(x.x, i.x));
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P> modf(tvec2<T, P> const & x, tvec2<T, P> & i)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<2, T, P> modf(vec<2, T, P> const & x, vec<2, T, P> & i)
 	{
-		return tvec2<T, P>(
+		return vec<2, T, P>(
 			modf(x.x, i.x),
 			modf(x.y, i.y));
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> modf(tvec3<T, P> const & x, tvec3<T, P> & i)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> modf(vec<3, T, P> const & x, vec<3, T, P> & i)
 	{
-		return tvec3<T, P>(
+		return vec<3, T, P>(
 			modf(x.x, i.x),
 			modf(x.y, i.y),
 			modf(x.z, i.z));
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> modf(tvec4<T, P> const & x, tvec4<T, P> & i)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, T, P> modf(vec<4, T, P> const & x, vec<4, T, P> & i)
 	{
-		return tvec4<T, P>(
+		return vec<4, T, P>(
 			modf(x.x, i.x),
 			modf(x.y, i.y),
 			modf(x.z, i.z),
@@ -511,94 +511,94 @@ namespace detail
 	//CHAR_BIT - 1)));
 
 	// min
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> min(vecType<T, P> const & a, T b)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> min(vecType<L, T, P> const & a, T b)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'min' only accept floating-point inputs for the interpolator a");
-		return detail::compute_min_vector<T, P, vecType, detail::is_aligned<P>::value>::call(a, vecType<T, P>(b));
+		return detail::compute_min_vector<L, T, P, vecType, detail::is_aligned<P>::value>::call(a, vecType<L, T, P>(b));
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> min(vecType<T, P> const & a, vecType<T, P> const & b)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> min(vecType<L, T, P> const & a, vecType<L, T, P> const & b)
 	{
-		return detail::compute_min_vector<T, P, vecType, detail::is_aligned<P>::value>::call(a, b);
+		return detail::compute_min_vector<L, T, P, vecType, detail::is_aligned<P>::value>::call(a, b);
 	}
 
 	// max
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> max(vecType<T, P> const & a, T b)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> max(vecType<L, T, P> const & a, T b)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'max' only accept floating-point inputs for the interpolator a");
-		return detail::compute_max_vector<T, P, vecType, detail::is_aligned<P>::value>::call(a, vecType<T, P>(b));
+		return detail::compute_max_vector<L, T, P, vecType, detail::is_aligned<P>::value>::call(a, vecType<L, T, P>(b));
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> max(vecType<T, P> const & a, vecType<T, P> const & b)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> max(vecType<L, T, P> const & a, vecType<L, T, P> const & b)
 	{
-		return detail::compute_max_vector<T, P, vecType, detail::is_aligned<P>::value>::call(a, b);
+		return detail::compute_max_vector<L, T, P, vecType, detail::is_aligned<P>::value>::call(a, b);
 	}
 
 	// clamp
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER genType clamp(genType x, genType minVal, genType maxVal)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || std::numeric_limits<genType>::is_integer || GLM_UNRESTRICTED_GENTYPE, "'clamp' only accept floating-point or integer inputs");
 		return min(max(x, minVal), maxVal);
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> clamp(vecType<T, P> const & x, T minVal, T maxVal)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> clamp(vecType<L, T, P> const & x, T minVal, T maxVal)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || std::numeric_limits<T>::is_integer || GLM_UNRESTRICTED_GENTYPE, "'clamp' only accept floating-point or integer inputs");
-		return detail::compute_clamp_vector<T, P, vecType, detail::is_aligned<P>::value>::call(x, vecType<T, P>(minVal), vecType<T, P>(maxVal));
+		return detail::compute_clamp_vector<L, T, P, vecType, detail::is_aligned<P>::value>::call(x, vecType<L, T, P>(minVal), vecType<L, T, P>(maxVal));
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> clamp(vecType<T, P> const & x, vecType<T, P> const & minVal, vecType<T, P> const & maxVal)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> clamp(vecType<L, T, P> const & x, vecType<L, T, P> const & minVal, vecType<L, T, P> const & maxVal)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || std::numeric_limits<T>::is_integer || GLM_UNRESTRICTED_GENTYPE, "'clamp' only accept floating-point or integer inputs");
-		return detail::compute_clamp_vector<T, P, vecType, detail::is_aligned<P>::value>::call(x, minVal, maxVal);
+		return detail::compute_clamp_vector<L, T, P, vecType, detail::is_aligned<P>::value>::call(x, minVal, maxVal);
 	}
 
-	template <typename genTypeT, typename genTypeU>
+	template<typename genTypeT, typename genTypeU>
 	GLM_FUNC_QUALIFIER genTypeT mix(genTypeT x, genTypeT y, genTypeU a)
 	{
 		return detail::compute_mix<genTypeT, genTypeU>::call(x, y, a);
 	}
 
-	template <typename T, typename U, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> mix(vecType<T, P> const & x, vecType<T, P> const & y, U a)
+	template<length_t L, typename T, typename U, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> mix(vecType<L, T, P> const & x, vecType<L, T, P> const & y, U a)
 	{
-		return detail::compute_mix_scalar<T, U, P, vecType, detail::is_aligned<P>::value>::call(x, y, a);
+		return detail::compute_mix_scalar<L, T, U, P, vecType, detail::is_aligned<P>::value>::call(x, y, a);
 	}
-	
-	template <typename T, typename U, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> mix(vecType<T, P> const & x, vecType<T, P> const & y, vecType<U, P> const & a)
+
+	template<length_t L, typename T, typename U, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> mix(vecType<L, T, P> const & x, vecType<L, T, P> const & y, vecType<L, U, P> const & a)
 	{
-		return detail::compute_mix_vector<T, U, P, vecType, detail::is_aligned<P>::value>::call(x, y, a);
+		return detail::compute_mix_vector<L, T, U, P, vecType, detail::is_aligned<P>::value>::call(x, y, a);
 	}
 
 	// step
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER genType step(genType edge, genType x)
 	{
 		return mix(static_cast<genType>(1), static_cast<genType>(0), glm::lessThan(x, edge));
 	}
 
-	template <template <typename, precision> class vecType, typename T, precision P>
-	GLM_FUNC_QUALIFIER vecType<T, P> step(T edge, vecType<T, P> const & x)
+	template<template<length_t, typename, precision> class vecType, length_t L, typename T, precision P>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> step(T edge, vecType<L, T, P> const & x)
 	{
-		return detail::compute_step_vector<T, P, vecType, detail::is_aligned<P>::value>::call(vecType<T, P>(edge), x);
+		return detail::compute_step_vector<L, T, P, vecType, detail::is_aligned<P>::value>::call(vecType<L, T, P>(edge), x);
 	}
 
-	template <template <typename, precision> class vecType, typename T, precision P>
-	GLM_FUNC_QUALIFIER vecType<T, P> step(vecType<T, P> const & edge, vecType<T, P> const & x)
+	template<template<length_t, typename, precision> class vecType, length_t L, typename T, precision P>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> step(vecType<L, T, P> const & edge, vecType<L, T, P> const & x)
 	{
-		return detail::compute_step_vector<T, P, vecType, detail::is_aligned<P>::value>::call(edge, x);
+		return detail::compute_step_vector<L, T, P, vecType, detail::is_aligned<P>::value>::call(edge, x);
 	}
 
 	// smoothstep
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER genType smoothstep(genType edge0, genType edge1, genType x)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'smoothstep' only accept floating-point inputs");
@@ -607,22 +607,22 @@ namespace detail
 		return tmp * tmp * (genType(3) - genType(2) * tmp);
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> smoothstep(T edge0, T edge1, vecType<T, P> const & x)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> smoothstep(T edge0, T edge1, vecType<L, T, P> const & x)
 	{
-		return detail::compute_smoothstep_vector<T, P, vecType, detail::is_aligned<P>::value>::call(vecType<T, P>(edge0), vecType<T, P>(edge1), x);
+		return detail::compute_smoothstep_vector<L, T, P, vecType, detail::is_aligned<P>::value>::call(vecType<L, T, P>(edge0), vecType<L, T, P>(edge1), x);
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> smoothstep(vecType<T, P> const & edge0, vecType<T, P> const & edge1, vecType<T, P> const & x)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> smoothstep(vecType<L, T, P> const & edge0, vecType<L, T, P> const & edge1, vecType<L, T, P> const & x)
 	{
-		return detail::compute_smoothstep_vector<T, P, vecType, detail::is_aligned<P>::value>::call(edge0, edge1, x);
+		return detail::compute_smoothstep_vector<L, T, P, vecType, detail::is_aligned<P>::value>::call(edge0, edge1, x);
 	}
 
 #	if GLM_HAS_CXX11_STL
 		using std::isnan;
 #	else
-		template <typename genType> 
+		template<typename genType> 
 		GLM_FUNC_QUALIFIER bool isnan(genType x)
 		{
 			GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'isnan' only accept floating-point inputs");
@@ -647,18 +647,18 @@ namespace detail
 		}
 #	endif
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<bool, P> isnan(vecType<T, P> const & x)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, bool, P> isnan(vecType<L, T, P> const & x)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'isnan' only accept floating-point inputs");
 
-		return detail::functor1<bool, T, P, vecType>::call(isnan, x);
+		return detail::functor1<L, bool, T, P>::call(isnan, x);
 	}
 
 #	if GLM_HAS_CXX11_STL
 		using std::isinf;
 #	else
-		template <typename genType> 
+		template<typename genType> 
 		GLM_FUNC_QUALIFIER bool isinf(genType x)
 		{
 			GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'isinf' only accept floating-point inputs");
@@ -686,12 +686,12 @@ namespace detail
 	}
 #	endif
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<bool, P> isinf(vecType<T, P> const & x)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, bool, P> isinf(vecType<L, T, P> const & x)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'isnan' only accept floating-point inputs");
 
-		return detail::functor1<bool, T, P, vecType>::call(isinf, x);
+		return detail::functor1<L, bool, T, P>::call(isinf, x);
 	}
 
 	GLM_FUNC_QUALIFIER int floatBitsToInt(float const & v)
@@ -699,10 +699,10 @@ namespace detail
 		return reinterpret_cast<int&>(const_cast<float&>(v));
 	}
 
-	template <template <typename, precision> class vecType, precision P>
-	GLM_FUNC_QUALIFIER vecType<int, P> floatBitsToInt(vecType<float, P> const & v)
+	template<template<length_t, typename, precision> class vecType, length_t L, precision P>
+	GLM_FUNC_QUALIFIER vecType<L, int, P> floatBitsToInt(vecType<L, float, P> const & v)
 	{
-		return reinterpret_cast<vecType<int, P>&>(const_cast<vecType<float, P>&>(v));
+		return reinterpret_cast<vecType<L, int, P>&>(const_cast<vecType<L, float, P>&>(v));
 	}
 
 	GLM_FUNC_QUALIFIER uint floatBitsToUint(float const & v)
@@ -710,10 +710,10 @@ namespace detail
 		return reinterpret_cast<uint&>(const_cast<float&>(v));
 	}
 
-	template <template <typename, precision> class vecType, precision P>
-	GLM_FUNC_QUALIFIER vecType<uint, P> floatBitsToUint(vecType<float, P> const & v)
+	template<template<length_t, typename, precision> class vecType, length_t L, precision P>
+	GLM_FUNC_QUALIFIER vecType<L, uint, P> floatBitsToUint(vecType<L, float, P> const & v)
 	{
-		return reinterpret_cast<vecType<uint, P>&>(const_cast<vecType<float, P>&>(v));
+		return reinterpret_cast<vecType<L, uint, P>&>(const_cast<vecType<L, float, P>&>(v));
 	}
 
 	GLM_FUNC_QUALIFIER float intBitsToFloat(int const & v)
@@ -721,10 +721,10 @@ namespace detail
 		return reinterpret_cast<float&>(const_cast<int&>(v));
 	}
 
-	template <template <typename, precision> class vecType, precision P>
-	GLM_FUNC_QUALIFIER vecType<float, P> intBitsToFloat(vecType<int, P> const & v)
+	template<template<length_t, typename, precision> class vecType, length_t L, precision P>
+	GLM_FUNC_QUALIFIER vecType<L, float, P> intBitsToFloat(vecType<L, int, P> const & v)
 	{
-		return reinterpret_cast<vecType<float, P>&>(const_cast<vecType<int, P>&>(v));
+		return reinterpret_cast<vecType<L, float, P>&>(const_cast<vecType<L, int, P>&>(v));
 	}
 
 	GLM_FUNC_QUALIFIER float uintBitsToFloat(uint const & v)
@@ -732,19 +732,19 @@ namespace detail
 		return reinterpret_cast<float&>(const_cast<uint&>(v));
 	}
 
-	template <template <typename, precision> class vecType, precision P>
-	GLM_FUNC_QUALIFIER vecType<float, P> uintBitsToFloat(vecType<uint, P> const & v)
+	template<template<length_t, typename, precision> class vecType, length_t L, precision P>
+	GLM_FUNC_QUALIFIER vecType<L, float, P> uintBitsToFloat(vecType<L, uint, P> const & v)
 	{
-		return reinterpret_cast<vecType<float, P>&>(const_cast<vecType<uint, P>&>(v));
+		return reinterpret_cast<vecType<L, float, P>&>(const_cast<vecType<L, uint, P>&>(v));
 	}
 	
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER genType fma(genType const & a, genType const & b, genType const & c)
 	{
 		return a * b + c;
 	}
 
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER genType frexp(genType x, int & exp)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'frexp' only accept floating-point inputs");
@@ -752,48 +752,48 @@ namespace detail
 		return std::frexp(x, &exp);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec1<T, P> frexp(tvec1<T, P> const & x, tvec1<int, P> & exp)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<1, T, P> frexp(vec<1, T, P> const & x, vec<1, int, P> & exp)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'frexp' only accept floating-point inputs");
 
-		return tvec1<T, P>(std::frexp(x.x, &exp.x));
+		return vec<1, T, P>(std::frexp(x.x, &exp.x));
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P> frexp(tvec2<T, P> const & x, tvec2<int, P> & exp)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<2, T, P> frexp(vec<2, T, P> const & x, vec<2, int, P> & exp)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'frexp' only accept floating-point inputs");
 
-		return tvec2<T, P>(
+		return vec<2, T, P>(
 			frexp(x.x, exp.x),
 			frexp(x.y, exp.y));
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> frexp(tvec3<T, P> const & x, tvec3<int, P> & exp)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> frexp(vec<3, T, P> const & x, vec<3, int, P> & exp)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'frexp' only accept floating-point inputs");
 
-		return tvec3<T, P>(
+		return vec<3, T, P>(
 			frexp(x.x, exp.x),
 			frexp(x.y, exp.y),
 			frexp(x.z, exp.z));
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> frexp(tvec4<T, P> const & x, tvec4<int, P> & exp)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, T, P> frexp(vec<4, T, P> const & x, vec<4, int, P> & exp)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'frexp' only accept floating-point inputs");
 
-		return tvec4<T, P>(
+		return vec<4, T, P>(
 			frexp(x.x, exp.x),
 			frexp(x.y, exp.y),
 			frexp(x.z, exp.z),
 			frexp(x.w, exp.w));
 	}
 
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER genType ldexp(genType const & x, int const & exp)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'ldexp' only accept floating-point inputs");
@@ -801,42 +801,42 @@ namespace detail
 		return std::ldexp(x, exp);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec1<T, P> ldexp(tvec1<T, P> const & x, tvec1<int, P> const & exp)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<1, T, P> ldexp(vec<1, T, P> const & x, vec<1, int, P> const & exp)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'ldexp' only accept floating-point inputs");
 
-		return tvec1<T, P>(
+		return vec<1, T, P>(
 			ldexp(x.x, exp.x));
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P> ldexp(tvec2<T, P> const & x, tvec2<int, P> const & exp)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<2, T, P> ldexp(vec<2, T, P> const & x, vec<2, int, P> const & exp)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'ldexp' only accept floating-point inputs");
 
-		return tvec2<T, P>(
+		return vec<2, T, P>(
 			ldexp(x.x, exp.x),
 			ldexp(x.y, exp.y));
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> ldexp(tvec3<T, P> const & x, tvec3<int, P> const & exp)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> ldexp(vec<3, T, P> const & x, vec<3, int, P> const & exp)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'ldexp' only accept floating-point inputs");
 
-		return tvec3<T, P>(
+		return vec<3, T, P>(
 			ldexp(x.x, exp.x),
 			ldexp(x.y, exp.y),
 			ldexp(x.z, exp.z));
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> ldexp(tvec4<T, P> const & x, tvec4<int, P> const & exp)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, T, P> ldexp(vec<4, T, P> const & x, vec<4, int, P> const & exp)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'ldexp' only accept floating-point inputs");
 
-		return tvec4<T, P>(
+		return vec<4, T, P>(
 			ldexp(x.x, exp.x),
 			ldexp(x.y, exp.y),
 			ldexp(x.z, exp.z),
diff --git a/glm/detail/func_common_simd.inl b/glm/detail/func_common_simd.inl
index c76f1802..e6daa269 100644
--- a/glm/detail/func_common_simd.inl
+++ b/glm/detail/func_common_simd.inl
@@ -10,191 +10,191 @@
 namespace glm{
 namespace detail
 {
-	template <precision P>
-	struct compute_abs_vector<float, P, tvec4, true>
+	template<precision P>
+	struct compute_abs_vector<4, float, P, vec, true>
 	{
-		GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const & v)
+		GLM_FUNC_QUALIFIER static vec<4, float, P> call(vec<4, float, P> const & v)
 		{
-			tvec4<float, P> result(uninitialize);
+			vec<4, float, P> result(uninitialize);
 			result.data = glm_vec4_abs(v.data);
 			return result;
 		}
 	};
 
-	template <precision P>
-	struct compute_abs_vector<int, P, tvec4, true>
+	template<precision P>
+	struct compute_abs_vector<4, int, P, vec, true>
 	{
-		GLM_FUNC_QUALIFIER static tvec4<int, P> call(tvec4<int, P> const & v)
+		GLM_FUNC_QUALIFIER static vec<4, int, P> call(vec<4, int, P> const & v)
 		{
-			tvec4<int, P> result(uninitialize);
+			vec<4, int, P> result(uninitialize);
 			result.data = glm_ivec4_abs(v.data);
 			return result;
 		}
 	};
 
-	template <precision P>
-	struct compute_floor<float, P, tvec4, true>
+	template<precision P>
+	struct compute_floor<4, float, P, vec, true>
 	{
-		GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const & v)
+		GLM_FUNC_QUALIFIER static vec<4, float, P> call(vec<4, float, P> const & v)
 		{
-			tvec4<float, P> result(uninitialize);
+			vec<4, float, P> result(uninitialize);
 			result.data = glm_vec4_floor(v.data);
 			return result;
 		}
 	};
 
-	template <precision P>
-	struct compute_ceil<float, P, tvec4, true>
+	template<precision P>
+	struct compute_ceil<4, float, P, vec, true>
 	{
-		GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const & v)
+		GLM_FUNC_QUALIFIER static vec<4, float, P> call(vec<4, float, P> const & v)
 		{
-			tvec4<float, P> result(uninitialize);
+			vec<4, float, P> result(uninitialize);
 			result.data = glm_vec4_ceil(v.data);
 			return result;
 		}
 	};
 
-	template <precision P>
-	struct compute_fract<float, P, tvec4, true>
+	template<precision P>
+	struct compute_fract<4, float, P, vec, true>
 	{
-		GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const & v)
+		GLM_FUNC_QUALIFIER static vec<4, float, P> call(vec<4, float, P> const & v)
 		{
-			tvec4<float, P> result(uninitialize);
+			vec<4, float, P> result(uninitialize);
 			result.data = glm_vec4_fract(v.data);
 			return result;
 		}
 	};
 
-	template <precision P>
-	struct compute_round<float, P, tvec4, true>
+	template<precision P>
+	struct compute_round<4, float, P, vec, true>
 	{
-		GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const & v)
+		GLM_FUNC_QUALIFIER static vec<4, float, P> call(vec<4, float, P> const & v)
 		{
-			tvec4<float, P> result(uninitialize);
+			vec<4, float, P> result(uninitialize);
 			result.data = glm_vec4_round(v.data);
 			return result;
 		}
 	};
 
-	template <precision P>
-	struct compute_mod<float, P, tvec4, true>
+	template<precision P>
+	struct compute_mod<4, float, P, vec, true>
 	{
-		GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const & x, tvec4<float, P> const & y)
+		GLM_FUNC_QUALIFIER static vec<4, float, P> call(vec<4, float, P> const & x, vec<4, float, P> const & y)
 		{
-			tvec4<float, P> result(uninitialize);
+			vec<4, float, P> result(uninitialize);
 			result.data = glm_vec4_mod(x.data, y.data);
 			return result;
 		}
 	};
 
-	template <precision P>
-	struct compute_min_vector<float, P, tvec4, true>
+	template<precision P>
+	struct compute_min_vector<4, float, P, vec, true>
 	{
-		GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const & v1, tvec4<float, P> const & v2)
+		GLM_FUNC_QUALIFIER static vec<4, float, P> call(vec<4, float, P> const & v1, vec<4, float, P> const & v2)
 		{
-			tvec4<float, P> result(uninitialize);
+			vec<4, float, P> result(uninitialize);
 			result.data = _mm_min_ps(v1.data, v2.data);
 			return result;
 		}
 	};
 
-	template <precision P>
-	struct compute_min_vector<int32, P, tvec4, true>
+	template<precision P>
+	struct compute_min_vector<4, int32, P, vec, true>
 	{
-		GLM_FUNC_QUALIFIER static tvec4<int32, P> call(tvec4<int32, P> const & v1, tvec4<int32, P> const & v2)
+		GLM_FUNC_QUALIFIER static vec<4, int32, P> call(vec<4, int32, P> const & v1, vec<4, int32, P> const & v2)
 		{
-			tvec4<int32, P> result(uninitialize);
+			vec<4, int32, P> result(uninitialize);
 			result.data = _mm_min_epi32(v1.data, v2.data);
 			return result;
 		}
 	};
 
-	template <precision P>
-	struct compute_min_vector<uint32, P, tvec4, true>
+	template<precision P>
+	struct compute_min_vector<4, uint32, P, vec, true>
 	{
-		GLM_FUNC_QUALIFIER static tvec4<int32, P> call(tvec4<uint32, P> const & v1, tvec4<uint32, P> const & v2)
+		GLM_FUNC_QUALIFIER static vec<4, int32, P> call(vec<4, uint32, P> const & v1, vec<4, uint32, P> const & v2)
 		{
-			tvec4<uint32, P> result(uninitialize);
+			vec<4, uint32, P> result(uninitialize);
 			result.data = _mm_min_epu32(v1.data, v2.data);
 			return result;
 		}
 	};
 
-	template <precision P>
-	struct compute_max_vector<float, P, tvec4, true>
+	template<precision P>
+	struct compute_max_vector<4, float, P, vec, true>
 	{
-		GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const & v1, tvec4<float, P> const & v2)
+		GLM_FUNC_QUALIFIER static vec<4, float, P> call(vec<4, float, P> const & v1, vec<4, float, P> const & v2)
 		{
-			tvec4<float, P> result(uninitialize);
+			vec<4, float, P> result(uninitialize);
 			result.data = _mm_max_ps(v1.data, v2.data);
 			return result;
 		}
 	};
 
-	template <precision P>
-	struct compute_max_vector<int32, P, tvec4, true>
+	template<precision P>
+	struct compute_max_vector<4, int32, P, vec, true>
 	{
-		GLM_FUNC_QUALIFIER static tvec4<int32, P> call(tvec4<int32, P> const & v1, tvec4<int32, P> const & v2)
+		GLM_FUNC_QUALIFIER static vec<4, int32, P> call(vec<4, int32, P> const & v1, vec<4, int32, P> const & v2)
 		{
-			tvec4<int32, P> result(uninitialize);
+			vec<4, int32, P> result(uninitialize);
 			result.data = _mm_max_epi32(v1.data, v2.data);
 			return result;
 		}
 	};
 
-	template <precision P>
-	struct compute_max_vector<uint32, P, tvec4, true>
+	template<precision P>
+	struct compute_max_vector<4, uint32, P, vec, true>
 	{
-		GLM_FUNC_QUALIFIER static tvec4<uint32, P> call(tvec4<uint32, P> const & v1, tvec4<uint32, P> const & v2)
+		GLM_FUNC_QUALIFIER static vec<4, uint32, P> call(vec<4, uint32, P> const & v1, vec<4, uint32, P> const & v2)
 		{
-			tvec4<uint32, P> result(uninitialize);
+			vec<4, uint32, P> result(uninitialize);
 			result.data = _mm_max_epu32(v1.data, v2.data);
 			return result;
 		}
 	};
 
-	template <precision P>
-	struct compute_clamp_vector<float, P, tvec4, true>
+	template<precision P>
+	struct compute_clamp_vector<4, float, P, vec, true>
 	{
-		GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const & x, tvec4<float, P> const & minVal, tvec4<float, P> const & maxVal)
+		GLM_FUNC_QUALIFIER static vec<4, float, P> call(vec<4, float, P> const & x, vec<4, float, P> const & minVal, vec<4, float, P> const & maxVal)
 		{
-			tvec4<float, P> result(uninitialize);
+			vec<4, float, P> result(uninitialize);
 			result.data = _mm_min_ps(_mm_max_ps(x.data, minVal.data), maxVal.data);
 			return result;
 		}
 	};
 
-	template <precision P>
-	struct compute_clamp_vector<int32, P, tvec4, true>
+	template<precision P>
+	struct compute_clamp_vector<4, int32, P, vec, true>
 	{
-		GLM_FUNC_QUALIFIER static tvec4<int32, P> call(tvec4<int32, P> const & x, tvec4<int32, P> const & minVal, tvec4<int32, P> const & maxVal)
+		GLM_FUNC_QUALIFIER static vec<4, int32, P> call(vec<4, int32, P> const & x, vec<4, int32, P> const & minVal, vec<4, int32, P> const & maxVal)
 		{
-			tvec4<int32, P> result(uninitialize);
+			vec<4, int32, P> result(uninitialize);
 			result.data = _mm_min_epi32(_mm_max_epi32(x.data, minVal.data), maxVal.data);
 			return result;
 		}
 	};
 
-	template <precision P>
-	struct compute_clamp_vector<uint32, P, tvec4, true>
+	template<precision P>
+	struct compute_clamp_vector<4, uint32, P, vec, true>
 	{
-		GLM_FUNC_QUALIFIER static tvec4<uint32, P> call(tvec4<uint32, P> const & x, tvec4<uint32, P> const & minVal, tvec4<uint32, P> const & maxVal)
+		GLM_FUNC_QUALIFIER static vec<4, uint32, P> call(vec<4, uint32, P> const & x, vec<4, uint32, P> const & minVal, vec<4, uint32, P> const & maxVal)
 		{
-			tvec4<uint32, P> result(uninitialize);
+			vec<4, uint32, P> result(uninitialize);
 			result.data = _mm_min_epu32(_mm_max_epu32(x.data, minVal.data), maxVal.data);
 			return result;
 		}
 	};
 
-	template <precision P>
-	struct compute_mix_vector<float, bool, P, tvec4, true>
+	template<precision P>
+	struct compute_mix_vector<4, float, bool, P, vec, true>
 	{
-		GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const & x, tvec4<float, P> const & y, tvec4<bool, P> const & a)
+		GLM_FUNC_QUALIFIER static vec<4, float, P> call(vec<4, float, P> const & x, vec<4, float, P> const & y, vec<4, bool, P> const & a)
 		{
 			__m128i const Load = _mm_set_epi32(-(int)a.w, -(int)a.z, -(int)a.y, -(int)a.x);
 			__m128 const Mask = _mm_castsi128_ps(Load);
 
-			tvec4<float, P> Result(uninitialize);
+			vec<4, float, P> Result(uninitialize);
 #			if 0 && GLM_ARCH & GLM_ARCH_AVX
 				Result.data = _mm_blendv_ps(x.data, y.data, Mask);
 #			else
@@ -204,23 +204,23 @@ namespace detail
 		}
 	};
 /* FIXME
-	template <precision P>
+	template<precision P>
 	struct compute_step_vector<float, P, tvec4>
 	{
-		GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const& edge, tvec4<float, P> const& x)
+		GLM_FUNC_QUALIFIER static vec<4, float, P> call(vec<4, float, P> const& edge, vec<4, float, P> const& x)
 		{
-			tvec4<float, P> result(uninitialize);
+			vec<4, float, P> result(uninitialize);
 			result.data = glm_vec4_step(edge.data, x.data);
 			return result;
 		}
 	};
 */
-	template <precision P>
-	struct compute_smoothstep_vector<float, P, tvec4, true>
+	template<precision P>
+	struct compute_smoothstep_vector<4, float, P, vec, true>
 	{
-		GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const& edge0, tvec4<float, P> const& edge1, tvec4<float, P> const& x)
+		GLM_FUNC_QUALIFIER static vec<4, float, P> call(vec<4, float, P> const& edge0, vec<4, float, P> const& edge1, vec<4, float, P> const& x)
 		{
-			tvec4<float, P> result(uninitialize);
+			vec<4, float, P> result(uninitialize);
 			result.data = glm_vec4_smoothstep(edge0.data, edge1.data, x.data);
 			return result;
 		}
diff --git a/glm/detail/func_exponential.hpp b/glm/detail/func_exponential.hpp
index a83de0bb..89ba5806 100644
--- a/glm/detail/func_exponential.hpp
+++ b/glm/detail/func_exponential.hpp
@@ -29,8 +29,8 @@ namespace glm
 	///
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/pow.xml">GLSL pow man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> pow(vecType<T, P> const & base, vecType<T, P> const & exponent);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, T, P> pow(vecType<L, T, P> const & base, vecType<L, T, P> const & exponent);
 
 	/// Returns the natural exponentiation of x, i.e., e^x.
 	///
@@ -39,8 +39,8 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/exp.xml">GLSL exp man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> exp(vecType<T, P> const & v);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, T, P> exp(vecType<L, T, P> const & v);
 
 	/// Returns the natural logarithm of v, i.e., 
 	/// returns the value y which satisfies the equation x = e^y. 
@@ -51,8 +51,8 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/log.xml">GLSL log man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> log(vecType<T, P> const & v);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, T, P> log(vecType<L, T, P> const & v);
 
 	/// Returns 2 raised to the v power.
 	/// 
@@ -61,8 +61,8 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/exp2.xml">GLSL exp2 man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> exp2(vecType<T, P> const & v);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, T, P> exp2(vecType<L, T, P> const & v);
 
 	/// Returns the base 2 log of x, i.e., returns the value y, 
 	/// which satisfies the equation x = 2 ^ y.
@@ -72,8 +72,8 @@ namespace glm
 	///
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/log2.xml">GLSL log2 man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> log2(vecType<T, P> const & v);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, T, P> log2(vecType<L, T, P> const & v);
 
 	/// Returns the positive square root of v.
 	/// 
@@ -82,10 +82,10 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/sqrt.xml">GLSL sqrt man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
-	//template <typename genType>
+	//template<typename genType>
 	//GLM_FUNC_DECL genType sqrt(genType const & x);
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> sqrt(vecType<T, P> const & v);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, T, P> sqrt(vecType<L, T, P> const & v);
 	
 	/// Returns the reciprocal of the positive square root of v.
 	/// 
@@ -94,8 +94,8 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/inversesqrt.xml">GLSL inversesqrt man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> inversesqrt(vecType<T, P> const & v);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, T, P> inversesqrt(vecType<L, T, P> const & v);
 
 	/// @}
 }//namespace glm
diff --git a/glm/detail/func_exponential.inl b/glm/detail/func_exponential.inl
index 227fe91a..3f51de1a 100644
--- a/glm/detail/func_exponential.inl
+++ b/glm/detail/func_exponential.inl
@@ -13,50 +13,50 @@ namespace detail
 #	if GLM_HAS_CXX11_STL
 		using std::log2;
 #	else
-		template <typename genType>
+		template<typename genType>
 		genType log2(genType Value)
 		{
 			return std::log(Value) * static_cast<genType>(1.4426950408889634073599246810019);
 		}
 #	endif
 
-	template <typename T, precision P, template <class, precision> class vecType, bool isFloat, bool Aligned>
+	template<length_t L, typename T, precision P, template<int, class, precision> class vecType, bool isFloat, bool Aligned>
 	struct compute_log2
 	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & vec)
+		GLM_FUNC_QUALIFIER static vec<L, T, P> call(vec<L, T, P> const& v)
 		{
-			return detail::functor1<T, T, P, vecType>::call(log2, vec);
+			return detail::functor1<L, T, T, P>::call(log2, v);
 		}
 	};
 
-	template <template <class, precision> class vecType, typename T, precision P, bool Aligned>
+	template<length_t L, typename T, precision P, bool Aligned>
 	struct compute_sqrt
 	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x)
+		GLM_FUNC_QUALIFIER static vec<L, T, P> call(vec<L, T, P> const& x)
 		{
-			return detail::functor1<T, T, P, vecType>::call(std::sqrt, x);
+			return detail::functor1<L, T, T, P>::call(std::sqrt, x);
 		}
 	};
 
-	template <template <class, precision> class vecType, typename T, precision P, bool Aligned>
+	template<length_t L, typename T, precision P, bool Aligned>
 	struct compute_inversesqrt
 	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x)
+		GLM_FUNC_QUALIFIER static vec<L, T, P> call(vec<L, T, P> const & x)
 		{
 			return static_cast<T>(1) / sqrt(x);
 		}
 	};
 		
-	template <template <class, precision> class vecType, bool Aligned>
-	struct compute_inversesqrt<vecType, float, lowp, Aligned>
+	template<length_t L, bool Aligned>
+	struct compute_inversesqrt<L, float, lowp, Aligned>
 	{
-		GLM_FUNC_QUALIFIER static vecType<float, lowp> call(vecType<float, lowp> const & x)
+		GLM_FUNC_QUALIFIER static vec<L, float, lowp> call(vec<L, float, lowp> const & x)
 		{
-			vecType<float, lowp> tmp(x);
-			vecType<float, lowp> xhalf(tmp * 0.5f);
-			vecType<uint, lowp>* p = reinterpret_cast<vecType<uint, lowp>*>(const_cast<vecType<float, lowp>*>(&x));
-			vecType<uint, lowp> i = vecType<uint, lowp>(0x5f375a86) - (*p >> vecType<uint, lowp>(1));
-			vecType<float, lowp>* ptmp = reinterpret_cast<vecType<float, lowp>*>(&i);
+			vec<L, float, lowp> tmp(x);
+			vec<L, float, lowp> xhalf(tmp * 0.5f);
+			vec<L, uint, lowp>* p = reinterpret_cast<vec<L, uint, lowp>*>(const_cast<vec<L, float, lowp>*>(&x));
+			vec<L, uint, lowp> i = vec<L, uint, lowp>(0x5f375a86) - (*p >> vec<L, uint, lowp>(1));
+			vec<L, float, lowp>* ptmp = reinterpret_cast<vec<L, float, lowp>*>(&i);
 			tmp = *ptmp;
 			tmp = tmp * (1.5f - xhalf * tmp * tmp);
 			return tmp;
@@ -66,30 +66,30 @@ namespace detail
 
 	// pow
 	using std::pow;
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> pow(vecType<T, P> const & base, vecType<T, P> const & exponent)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> pow(vecType<L, T, P> const & base, vecType<L, T, P> const& exponent)
 	{
-		return detail::functor2<T, P, vecType>::call(pow, base, exponent);
+		return detail::functor2<L, T, P>::call(pow, base, exponent);
 	}
 
 	// exp
 	using std::exp;
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> exp(vecType<T, P> const & x)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> exp(vecType<L, T, P> const& x)
 	{
-		return detail::functor1<T, T, P, vecType>::call(exp, x);
+		return detail::functor1<L, T, T, P>::call(exp, x);
 	}
 
 	// log
 	using std::log;
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> log(vecType<T, P> const & x)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> log(vecType<L, T, P> const& x)
 	{
-		return detail::functor1<T, T, P, vecType>::call(log, x);
+		return detail::functor1<L, T, T, P>::call(log, x);
 	}
 
 	//exp2, ln2 = 0.69314718055994530941723212145818f
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER genType exp2(genType x)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'exp2' only accept floating-point inputs");
@@ -97,46 +97,46 @@ namespace detail
 		return std::exp(static_cast<genType>(0.69314718055994530941723212145818) * x);
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> exp2(vecType<T, P> const & x)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> exp2(vecType<L, T, P> const& x)
 	{
-		return detail::functor1<T, T, P, vecType>::call(exp2, x);
+		return detail::functor1<L, T, T, P>::call(exp2, x);
 	}
 
 	// log2, ln2 = 0.69314718055994530941723212145818f
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER genType log2(genType x)
 	{
-		return log2(tvec1<genType>(x)).x;
+		return log2(vec<1, genType>(x)).x;
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> log2(vecType<T, P> const & x)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> log2(vecType<L, T, P> const& x)
 	{
-		return detail::compute_log2<T, P, vecType, std::numeric_limits<T>::is_iec559, detail::is_aligned<P>::value>::call(x);
+		return detail::compute_log2<L, T, P, vecType, std::numeric_limits<T>::is_iec559, detail::is_aligned<P>::value>::call(x);
 	}
 
 	// sqrt
 	using std::sqrt;
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> sqrt(vecType<T, P> const & x)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> sqrt(vecType<L, T, P> const& x)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'sqrt' only accept floating-point inputs");
-		return detail::compute_sqrt<vecType, T, P, detail::is_aligned<P>::value>::call(x);
+		return detail::compute_sqrt<L, T, P, detail::is_aligned<P>::value>::call(x);
 	}
 
 	// inversesqrt
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER genType inversesqrt(genType x)
 	{
 		return static_cast<genType>(1) / sqrt(x);
 	}
 	
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> inversesqrt(vecType<T, P> const & x)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> inversesqrt(vecType<L, T, P> const& x)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'inversesqrt' only accept floating-point inputs");
-		return detail::compute_inversesqrt<vecType, T, P, detail::is_aligned<P>::value>::call(x);
+		return detail::compute_inversesqrt<L, T, P, detail::is_aligned<P>::value>::call(x);
 	}
 }//namespace glm
 
diff --git a/glm/detail/func_exponential_simd.inl b/glm/detail/func_exponential_simd.inl
index d7529ba3..9ac60ba9 100644
--- a/glm/detail/func_exponential_simd.inl
+++ b/glm/detail/func_exponential_simd.inl
@@ -8,23 +8,23 @@
 namespace glm{
 namespace detail
 {
-	template <precision P>
-	struct compute_sqrt<tvec4, float, P, true>
+	template<precision P>
+	struct compute_sqrt<4, float, P, true>
 	{
-		GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const & v)
+		GLM_FUNC_QUALIFIER static vec<4, float, P> call(vec<4, float, P> const & v)
 		{
-			tvec4<float, P> result(uninitialize);
+			vec<4, float, P> result(uninitialize);
 			result.data = _mm_sqrt_ps(v.data);
 			return result;
 		}
 	};
 
-	template <>
-	struct compute_sqrt<tvec4, float, aligned_lowp, true>
+	template<>
+	struct compute_sqrt<4, float, aligned_lowp, true>
 	{
-		GLM_FUNC_QUALIFIER static tvec4<float, aligned_lowp> call(tvec4<float, aligned_lowp> const & v)
+		GLM_FUNC_QUALIFIER static vec<4, float, aligned_lowp> call(vec<4, float, aligned_lowp> const & v)
 		{
-			tvec4<float, aligned_lowp> result(uninitialize);
+			vec<4, float, aligned_lowp> result(uninitialize);
 			result.data = glm_vec4_sqrt_lowp(v.data);
 			return result;
 		}
diff --git a/glm/detail/func_geometric.hpp b/glm/detail/func_geometric.hpp
index 2f39bf5b..d5a737b5 100644
--- a/glm/detail/func_geometric.hpp
+++ b/glm/detail/func_geometric.hpp
@@ -23,9 +23,9 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/length.xml">GLSL length man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
-	template <typename T, precision P, template <typename, precision> class vecType>
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
 	GLM_FUNC_DECL T length(
-		vecType<T, P> const & x);
+		vecType<L, T, P> const& x);
 
 	/// Returns the distance betwwen p0 and p1, i.e., length(p0 - p1).
 	///
@@ -33,10 +33,10 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/distance.xml">GLSL distance man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
-	template <typename T, precision P, template <typename, precision> class vecType>
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
 	GLM_FUNC_DECL T distance(
-		vecType<T, P> const & p0,
-		vecType<T, P> const & p1);
+		vecType<L, T, P> const& p0,
+		vecType<L, T, P> const& p1);
 
 	/// Returns the dot product of x and y, i.e., result = x * y.
 	///
@@ -44,10 +44,10 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/dot.xml">GLSL dot man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
-	template <typename T, precision P, template <typename, precision> class vecType>
+	template<length_t L, typename T, precision P>
 	GLM_FUNC_DECL T dot(
-		vecType<T, P> const & x,
-		vecType<T, P> const & y);
+		vec<L, T, P> const & x,
+		vec<L, T, P> const & y);
 
 	/// Returns the cross product of x and y.
 	///
@@ -55,19 +55,19 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/cross.xml">GLSL cross man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> cross(
-		tvec3<T, P> const & x,
-		tvec3<T, P> const & y);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<3, T, P> cross(
+		vec<3, T, P> const & x,
+		vec<3, T, P> const & y);
 
 	/// Returns a vector in the same direction as x but with length of 1.
 	/// According to issue 10 GLSL 1.10 specification, if length(x) == 0 then result is undefined and generate an error.
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/normalize.xml">GLSL normalize man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> normalize(
-		vecType<T, P> const & x);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, T, P> normalize(
+		vecType<L, T, P> const& x);
 
 	/// If dot(Nref, I) < 0.0, return N, otherwise, return -N.
 	///
@@ -75,11 +75,11 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/faceforward.xml">GLSL faceforward man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> faceforward(
-		vecType<T, P> const & N,
-		vecType<T, P> const & I,
-		vecType<T, P> const & Nref);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, T, P> faceforward(
+		vecType<L, T, P> const& N,
+		vecType<L, T, P> const& I,
+		vecType<L, T, P> const& Nref);
 
 	/// For the incident vector I and surface orientation N, 
 	/// returns the reflection direction : result = I - 2.0 * dot(N, I) * N.
@@ -88,7 +88,7 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/reflect.xml">GLSL reflect man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL genType reflect(
 		genType const & I,
 		genType const & N);
@@ -101,10 +101,10 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/refract.xml">GLSL refract man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> refract(
-		vecType<T, P> const & I,
-		vecType<T, P> const & N,
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, T, P> refract(
+		vecType<L, T, P> const& I,
+		vecType<L, T, P> const& N,
 		T eta);
 
 	/// @}
diff --git a/glm/detail/func_geometric.inl b/glm/detail/func_geometric.inl
index 07137c3a..dd891d63 100644
--- a/glm/detail/func_geometric.inl
+++ b/glm/detail/func_geometric.inl
@@ -10,84 +10,84 @@
 namespace glm{
 namespace detail
 {
-	template <template <typename, precision> class vecType, typename T, precision P, bool Aligned>
+	template<template<length_t, typename, precision> class vecType, length_t L, typename T, precision P, bool Aligned>
 	struct compute_length
 	{
-		GLM_FUNC_QUALIFIER static T call(vecType<T, P> const & v)
+		GLM_FUNC_QUALIFIER static T call(vecType<L, T, P> const & v)
 		{
 			return sqrt(dot(v, v));
 		}
 	};
 
-	template <template <typename, precision> class vecType, typename T, precision P, bool Aligned>
+	template<template<length_t, typename, precision> class vecType, length_t L, typename T, precision P, bool Aligned>
 	struct compute_distance
 	{
-		GLM_FUNC_QUALIFIER static T call(vecType<T, P> const & p0, vecType<T, P> const & p1)
+		GLM_FUNC_QUALIFIER static T call(vecType<L, T, P> const & p0, vecType<L, T, P> const & p1)
 		{
 			return length(p1 - p0);
 		}
 	};
 
-	template <template <class, precision> class vecType, typename T, precision P, bool Aligned>
+	template<typename V, typename T, bool Aligned>
 	struct compute_dot{};
 
-	template <typename T, precision P, bool Aligned>
-	struct compute_dot<tvec1, T, P, Aligned>
+	template<typename T, precision P, bool Aligned>
+	struct compute_dot<vec<1, T, P>, T, Aligned>
 	{
-		GLM_FUNC_QUALIFIER static T call(tvec1<T, P> const & a, tvec1<T, P> const & b)
+		GLM_FUNC_QUALIFIER static T call(vec<1, T, P> const & a, vec<1, T, P> const & b)
 		{
 			return a.x * b.x;
 		}
 	};
 
-	template <typename T, precision P, bool Aligned>
-	struct compute_dot<tvec2, T, P, Aligned>
+	template<typename T, precision P, bool Aligned>
+	struct compute_dot<vec<2, T, P>, T, Aligned>
 	{
-		GLM_FUNC_QUALIFIER static T call(tvec2<T, P> const & x, tvec2<T, P> const & y)
+		GLM_FUNC_QUALIFIER static T call(vec<2, T, P> const & a, vec<2, T, P> const & b)
 		{
-			tvec2<T, P> tmp(x * y);
+			vec<2, T, P> tmp(a * b);
 			return tmp.x + tmp.y;
 		}
 	};
 
-	template <typename T, precision P, bool Aligned>
-	struct compute_dot<tvec3, T, P, Aligned>
+	template<typename T, precision P, bool Aligned>
+	struct compute_dot<vec<3, T, P>, T, Aligned>
 	{
-		GLM_FUNC_QUALIFIER static T call(tvec3<T, P> const & x, tvec3<T, P> const & y)
+		GLM_FUNC_QUALIFIER static T call(vec<3, T, P> const & a, vec<3, T, P> const & b)
 		{
-			tvec3<T, P> tmp(x * y);
+			vec<3, T, P> tmp(a * b);
 			return tmp.x + tmp.y + tmp.z;
 		}
 	};
 
-	template <typename T, precision P, bool Aligned>
-	struct compute_dot<tvec4, T, P, Aligned>
+	template<typename T, precision P, bool Aligned>
+	struct compute_dot<vec<4, T, P>, T, Aligned>
 	{
-		GLM_FUNC_QUALIFIER static T call(tvec4<T, P> const & x, tvec4<T, P> const & y)
+		GLM_FUNC_QUALIFIER static T call(vec<4, T, P> const & a, vec<4, T, P> const & b)
 		{
-			tvec4<T, P> tmp(x * y);
+			vec<4, T, P> tmp(a * b);
 			return (tmp.x + tmp.y) + (tmp.z + tmp.w);
 		}
 	};
 
-	template <typename T, precision P, bool Aligned>
+	template<typename T, precision P, bool Aligned>
 	struct compute_cross
 	{
-		GLM_FUNC_QUALIFIER static tvec3<T, P> call(tvec3<T, P> const & x, tvec3<T, P> const & y)
+		GLM_FUNC_QUALIFIER static vec<3, T, P> call(vec<3, T, P> const & x, vec<3, T, P> const & y)
 		{
 			GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'cross' accepts only floating-point inputs");
 
-			return tvec3<T, P>(
+			return vec<3, T, P>(
 				x.y * y.z - y.y * x.z,
 				x.z * y.x - y.z * x.x,
 				x.x * y.y - y.x * x.y);
 		}
 	};
 
-	template <typename T, precision P, template <typename, precision> class vecType, bool Aligned>
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType, bool Aligned>
 	struct compute_normalize
 	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & v)
+		GLM_FUNC_QUALIFIER static vecType<L, T, P> call(vecType<L, T, P> const & v)
 		{
 			GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'normalize' accepts only floating-point inputs");
 
@@ -95,10 +95,10 @@ namespace detail
 		}
 	};
 
-	template <typename T, precision P, template <typename, precision> class vecType, bool Aligned>
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType, bool Aligned>
 	struct compute_faceforward
 	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & N, vecType<T, P> const & I, vecType<T, P> const & Nref)
+		GLM_FUNC_QUALIFIER static vecType<L, T, P> call(vecType<L, T, P> const & N, vecType<L, T, P> const & I, vecType<L, T, P> const & Nref)
 		{
 			GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'normalize' accepts only floating-point inputs");
 
@@ -106,19 +106,19 @@ namespace detail
 		}
 	};
 
-	template <typename T, precision P, template <typename, precision> class vecType, bool Aligned>
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType, bool Aligned>
 	struct compute_reflect
 	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & I, vecType<T, P> const & N)
+		GLM_FUNC_QUALIFIER static vecType<L, T, P> call(vecType<L, T, P> const & I, vecType<L, T, P> const & N)
 		{
 			return I - N * dot(N, I) * static_cast<T>(2);
 		}
 	};
 
-	template <typename T, precision P, template <typename, precision> class vecType, bool Aligned>
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType, bool Aligned>
 	struct compute_refract
 	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & I, vecType<T, P> const & N, T eta)
+		GLM_FUNC_QUALIFIER static vecType<L, T, P> call(vecType<L, T, P> const & I, vecType<L, T, P> const & N, T eta)
 		{
 			T const dotValue(dot(N, I));
 			T const k(static_cast<T>(1) - eta * eta * (static_cast<T>(1) - dotValue * dotValue));
@@ -128,7 +128,7 @@ namespace detail
 }//namespace detail
 
 	// length
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER genType length(genType x)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'length' accepts only floating-point inputs");
@@ -136,16 +136,16 @@ namespace detail
 		return abs(x);
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER T length(vecType<T, P> const & v)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER T length(vecType<L, T, P> const & v)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'length' accepts only floating-point inputs");
 
-		return detail::compute_length<vecType, T, P, detail::is_aligned<P>::value>::call(v);
+		return detail::compute_length<vecType, L, T, P, detail::is_aligned<P>::value>::call(v);
 	}
 
 	// distance
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER genType distance(genType const & p0, genType const & p1)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'distance' accepts only floating-point inputs");
@@ -153,36 +153,43 @@ namespace detail
 		return length(p1 - p0);
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER T distance(vecType<T, P> const & p0, vecType<T, P> const & p1)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER T distance(vecType<L, T, P> const & p0, vecType<L, T, P> const & p1)
 	{
-		return detail::compute_distance<vecType, T, P, detail::is_aligned<P>::value>::call(p0, p1);
+		return detail::compute_distance<vecType, L, T, P, detail::is_aligned<P>::value>::call(p0, p1);
 	}
 
 	// dot
-	template <typename T>
+	template<typename T>
 	GLM_FUNC_QUALIFIER T dot(T x, T y)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'dot' accepts only floating-point inputs");
 		return x * y;
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER T dot(vecType<T, P> const & x, vecType<T, P> const & y)
+	template<length_t L, typename T, precision P>
+	GLM_FUNC_QUALIFIER T dot(vec<L, T, P> const & x, vec<L, T, P> const & y)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'dot' accepts only floating-point inputs");
-		return detail::compute_dot<vecType, T, P, detail::is_aligned<P>::value>::call(x, y);
+		return detail::compute_dot<vec<L, T, P>, T, detail::is_aligned<P>::value>::call(x, y);
+	}
+
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER T dot(tquat<T, P> const & x, tquat<T, P> const & y)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'dot' accepts only floating-point inputs");
+		return detail::compute_dot<tquat<T, P>, T, detail::is_aligned<P>::value>::call(x, y);
 	}
 
 	// cross
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> cross(tvec3<T, P> const & x, tvec3<T, P> const & y)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> cross(vec<3, T, P> const & x, vec<3, T, P> const & y)
 	{
 		return detail::compute_cross<T, P, detail::is_aligned<P>::value>::call(x, y);
 	}
 
 	// normalize
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER genType normalize(genType const & x)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'normalize' accepts only floating-point inputs");
@@ -190,42 +197,42 @@ namespace detail
 		return x < genType(0) ? genType(-1) : genType(1);
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> normalize(vecType<T, P> const & x)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> normalize(vecType<L, T, P> const & x)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'normalize' accepts only floating-point inputs");
 
-		return detail::compute_normalize<T, P, vecType, detail::is_aligned<P>::value>::call(x);
+		return detail::compute_normalize<L, T, P, vecType, detail::is_aligned<P>::value>::call(x);
 	}
 
 	// faceforward
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER genType faceforward(genType const & N, genType const & I, genType const & Nref)
 	{
 		return dot(Nref, I) < static_cast<genType>(0) ? N : -N;
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> faceforward(vecType<T, P> const & N, vecType<T, P> const & I, vecType<T, P> const & Nref)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> faceforward(vecType<L, T, P> const & N, vecType<L, T, P> const & I, vecType<L, T, P> const & Nref)
 	{
-		return detail::compute_faceforward<T, P, vecType, detail::is_aligned<P>::value>::call(N, I, Nref);
+		return detail::compute_faceforward<L, T, P, vecType, detail::is_aligned<P>::value>::call(N, I, Nref);
 	}
 
 	// reflect
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER genType reflect(genType const & I, genType const & N)
 	{
 		return I - N * dot(N, I) * genType(2);
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> reflect(vecType<T, P> const & I, vecType<T, P> const & N)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> reflect(vecType<L, T, P> const & I, vecType<L, T, P> const & N)
 	{
-		return detail::compute_reflect<T, P, vecType, detail::is_aligned<P>::value>::call(I, N);
+		return detail::compute_reflect<L, T, P, vecType, detail::is_aligned<P>::value>::call(I, N);
 	}
 
 	// refract
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER genType refract(genType const & I, genType const & N, genType eta)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'refract' accepts only floating-point inputs");
@@ -234,11 +241,11 @@ namespace detail
 		return (eta * I - (eta * dotValue + sqrt(k)) * N) * static_cast<genType>(k >= static_cast<genType>(0));
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> refract(vecType<T, P> const & I, vecType<T, P> const & N, T eta)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> refract(vecType<L, T, P> const & I, vecType<L, T, P> const & N, T eta)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'refract' accepts only floating-point inputs");
-		return detail::compute_refract<T, P, vecType, detail::is_aligned<P>::value>::call(I, N, eta);
+		return detail::compute_refract<L, T, P, vecType, detail::is_aligned<P>::value>::call(I, N, eta);
 	}
 }//namespace glm
 
diff --git a/glm/detail/func_geometric_simd.inl b/glm/detail/func_geometric_simd.inl
index f0d14a26..7ddf9e05 100644
--- a/glm/detail/func_geometric_simd.inl
+++ b/glm/detail/func_geometric_simd.inl
@@ -8,87 +8,87 @@
 namespace glm{
 namespace detail
 {
-	template <precision P>
-	struct compute_length<tvec4, float, P, true>
+	template<precision P>
+	struct compute_length<vec, 4, float, P, true>
 	{
-		GLM_FUNC_QUALIFIER static float call(tvec4<float, P> const & v)
+		GLM_FUNC_QUALIFIER static float call(vec<4, float, P> const & v)
 		{
 			return _mm_cvtss_f32(glm_vec4_length(v.data));
 		}
 	};
 
-	template <precision P>
-	struct compute_distance<tvec4, float, P, true>
+	template<precision P>
+	struct compute_distance<vec, 4, float, P, true>
 	{
-		GLM_FUNC_QUALIFIER static float call(tvec4<float, P> const & p0, tvec4<float, P> const & p1)
+		GLM_FUNC_QUALIFIER static float call(vec<4, float, P> const & p0, vec<4, float, P> const & p1)
 		{
 			return _mm_cvtss_f32(glm_vec4_distance(p0.data, p1.data));
 		}
 	};
 
-	template <precision P>
-	struct compute_dot<tvec4, float, P, true>
+	template<precision P>
+	struct compute_dot<vec<4, float, P>, float, true>
 	{
-		GLM_FUNC_QUALIFIER static float call(tvec4<float, P> const& x, tvec4<float, P> const& y)
+		GLM_FUNC_QUALIFIER static float call(vec<4, float, P> const& x, vec<4, float, P> const& y)
 		{
 			return _mm_cvtss_f32(glm_vec1_dot(x.data, y.data));
 		}
 	};
 
-	template <precision P>
+	template<precision P>
 	struct compute_cross<float, P, true>
 	{
-		GLM_FUNC_QUALIFIER static tvec3<float, P> call(tvec3<float, P> const & a, tvec3<float, P> const & b)
+		GLM_FUNC_QUALIFIER static vec<3, float, P> call(vec<3, float, P> const & a, vec<3, float, P> const & b)
 		{
 			__m128 const set0 = _mm_set_ps(0.0f, a.z, a.y, a.x);
 			__m128 const set1 = _mm_set_ps(0.0f, b.z, b.y, b.x);
 			__m128 const xpd0 = glm_vec4_cross(set0, set1);
 
-			tvec4<float, P> result(uninitialize);
+			vec<4, float, P> result(uninitialize);
 			result.data = xpd0;
-			return tvec3<float, P>(result);
+			return vec<3, float, P>(result);
 		}
 	};
 
-	template <precision P>
-	struct compute_normalize<float, P, tvec4, true>
+	template<precision P>
+	struct compute_normalize<4, float, P, vec, true>
 	{
-		GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const & v)
+		GLM_FUNC_QUALIFIER static vec<4, float, P> call(vec<4, float, P> const & v)
 		{
-			tvec4<float, P> result(uninitialize);
+			vec<4, float, P> result(uninitialize);
 			result.data = glm_vec4_normalize(v.data);
 			return result;
 		}
 	};
 
-	template <precision P>
-	struct compute_faceforward<float, P, tvec4, true>
+	template<precision P>
+	struct compute_faceforward<4, float, P, vec, true>
 	{
-		GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const& N, tvec4<float, P> const& I, tvec4<float, P> const& Nref)
+		GLM_FUNC_QUALIFIER static vec<4, float, P> call(vec<4, float, P> const& N, vec<4, float, P> const& I, vec<4, float, P> const& Nref)
 		{
-			tvec4<float, P> result(uninitialize);
+			vec<4, float, P> result(uninitialize);
 			result.data = glm_vec4_faceforward(N.data, I.data, Nref.data);
 			return result;
 		}
 	};
 
-	template <precision P>
-	struct compute_reflect<float, P, tvec4, true>
+	template<precision P>
+	struct compute_reflect<4, float, P, vec, true>
 	{
-		GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const& I, tvec4<float, P> const& N)
+		GLM_FUNC_QUALIFIER static vec<4, float, P> call(vec<4, float, P> const& I, vec<4, float, P> const& N)
 		{
-			tvec4<float, P> result(uninitialize);
+			vec<4, float, P> result(uninitialize);
 			result.data = glm_vec4_reflect(I.data, N.data);
 			return result;
 		}
 	};
 
-	template <precision P>
-	struct compute_refract<float, P, tvec4, true>
+	template<precision P>
+	struct compute_refract<4, float, P, vec, true>
 	{
-		GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const& I, tvec4<float, P> const& N, float eta)
+		GLM_FUNC_QUALIFIER static vec<4, float, P> call(vec<4, float, P> const& I, vec<4, float, P> const& N, float eta)
 		{
-			tvec4<float, P> result(uninitialize);
+			vec<4, float, P> result(uninitialize);
 			result.data = glm_vec4_refract(I.data, N.data, _mm_set1_ps(eta));
 			return result;
 		}
diff --git a/glm/detail/func_integer.hpp b/glm/detail/func_integer.hpp
index bd195a9c..375d6014 100644
--- a/glm/detail/func_integer.hpp
+++ b/glm/detail/func_integer.hpp
@@ -30,11 +30,11 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/uaddCarry.xml">GLSL uaddCarry man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
-	template <precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<uint, P> uaddCarry(
-		vecType<uint, P> const & x,
-		vecType<uint, P> const & y,
-		vecType<uint, P> & carry);
+	template<length_t L, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, uint, P> uaddCarry(
+		vecType<L, uint, P> const & x,
+		vecType<L, uint, P> const & y,
+		vecType<L, uint, P> & carry);
 
 	/// Subtracts the 32-bit unsigned integer y from x, returning
 	/// the difference if non-negative, or pow(2, 32) plus the difference
@@ -44,11 +44,11 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/usubBorrow.xml">GLSL usubBorrow man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
-	template <precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<uint, P> usubBorrow(
-		vecType<uint, P> const & x,
-		vecType<uint, P> const & y,
-		vecType<uint, P> & borrow);
+	template<length_t L, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, uint, P> usubBorrow(
+		vecType<L, uint, P> const & x,
+		vecType<L, uint, P> const & y,
+		vecType<L, uint, P> & borrow);
 
 	/// Multiplies 32-bit integers x and y, producing a 64-bit
 	/// result. The 32 least-significant bits are returned in lsb.
@@ -58,12 +58,12 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/umulExtended.xml">GLSL umulExtended man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
-	template <precision P, template <typename, precision> class vecType>
+	template<length_t L, precision P, template<length_t, typename, precision> class vecType>
 	GLM_FUNC_DECL void umulExtended(
-		vecType<uint, P> const & x,
-		vecType<uint, P> const & y,
-		vecType<uint, P> & msb,
-		vecType<uint, P> & lsb);
+		vecType<L, uint, P> const & x,
+		vecType<L, uint, P> const & y,
+		vecType<L, uint, P> & msb,
+		vecType<L, uint, P> & lsb);
 		
 	/// Multiplies 32-bit integers x and y, producing a 64-bit
 	/// result. The 32 least-significant bits are returned in lsb.
@@ -73,12 +73,12 @@ namespace glm
 	///
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/imulExtended.xml">GLSL imulExtended man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
-	template <precision P, template <typename, precision> class vecType>
+	template<length_t L, precision P, template<length_t, typename, precision> class vecType>
 	GLM_FUNC_DECL void imulExtended(
-		vecType<int, P> const & x,
-		vecType<int, P> const & y,
-		vecType<int, P> & msb,
-		vecType<int, P> & lsb);
+		vecType<L, int, P> const & x,
+		vecType<L, int, P> const & y,
+		vecType<L, int, P> & msb,
+		vecType<L, int, P> & lsb);
 
 	/// Extracts bits [offset, offset + bits - 1] from value,
 	/// returning them in the least significant bits of the result.
@@ -95,9 +95,9 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/bitfieldExtract.xml">GLSL bitfieldExtract man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> bitfieldExtract(
-		vecType<T, P> const & Value,
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, T, P> bitfieldExtract(
+		vecType<L, T, P> const& Value,
 		int Offset,
 		int Bits);
 
@@ -115,10 +115,10 @@ namespace glm
 	///
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/bitfieldInsert.xml">GLSL bitfieldInsert man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> bitfieldInsert(
-		vecType<T, P> const & Base,
-		vecType<T, P> const & Insert,
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, T, P> bitfieldInsert(
+		vecType<L, T, P> const& Base,
+		vecType<L, T, P> const& Insert,
 		int Offset,
 		int Bits);
 
@@ -130,8 +130,8 @@ namespace glm
 	///
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/bitfieldReverse.xml">GLSL bitfieldReverse man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> bitfieldReverse(vecType<T, P> const & v);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, T, P> bitfieldReverse(vecType<L, T, P> const & v);
 
 	/// Returns the number of bits set to 1 in the binary representation of value.
 	///
@@ -139,7 +139,7 @@ namespace glm
 	///
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/bitCount.xml">GLSL bitCount man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL int bitCount(genType v);
 
 	/// Returns the number of bits set to 1 in the binary representation of value.
@@ -148,8 +148,8 @@ namespace glm
 	///
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/bitCount.xml">GLSL bitCount man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<int, P> bitCount(vecType<T, P> const & v);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, int, P> bitCount(vecType<L, T, P> const & v);
 
 	/// Returns the bit number of the least significant bit set to
 	/// 1 in the binary representation of value. 
@@ -159,7 +159,7 @@ namespace glm
 	///
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/findLSB.xml">GLSL findLSB man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
-	template <typename genIUType>
+	template<typename genIUType>
 	GLM_FUNC_DECL int findLSB(genIUType x);
 
 	/// Returns the bit number of the least significant bit set to
@@ -170,8 +170,8 @@ namespace glm
 	///
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/findLSB.xml">GLSL findLSB man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<int, P> findLSB(vecType<T, P> const & v);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, int, P> findLSB(vecType<L, T, P> const & v);
 
 	/// Returns the bit number of the most significant bit in the binary representation of value.
 	/// For positive integers, the result will be the bit number of the most significant bit set to 1. 
@@ -182,7 +182,7 @@ namespace glm
 	///
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/findMSB.xml">GLSL findMSB man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
-	template <typename genIUType>
+	template<typename genIUType>
 	GLM_FUNC_DECL int findMSB(genIUType x);
 
 	/// Returns the bit number of the most significant bit in the binary representation of value.
@@ -194,8 +194,8 @@ namespace glm
 	///
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/findMSB.xml">GLSL findMSB man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<int, P> findMSB(vecType<T, P> const & v);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, int, P> findMSB(vecType<L, T, P> const & v);
 
 	/// @}
 }//namespace glm
diff --git a/glm/detail/func_integer.inl b/glm/detail/func_integer.inl
index 47be412a..d4b184c8 100644
--- a/glm/detail/func_integer.inl
+++ b/glm/detail/func_integer.inl
@@ -24,49 +24,49 @@
 namespace glm{
 namespace detail
 {
-	template <typename T>
+	template<typename T>
 	GLM_FUNC_QUALIFIER T mask(T Bits)
 	{
 		return Bits >= sizeof(T) * 8 ? ~static_cast<T>(0) : (static_cast<T>(1) << Bits) - static_cast<T>(1);
 	}
 
-	template <typename T, glm::precision P, template <typename, glm::precision> class vecType, bool Aligned, bool EXEC>
+	template<length_t L, typename T, glm::precision P, template<length_t, typename, precision> class vecType, bool Aligned, bool EXEC>
 	struct compute_bitfieldReverseStep
 	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & v, T, T)
+		GLM_FUNC_QUALIFIER static vecType<L, T, P> call(vecType<L, T, P> const& v, T, T)
 		{
 			return v;
 		}
 	};
 
-	template <typename T, glm::precision P, template <typename, glm::precision> class vecType, bool Aligned>
-	struct compute_bitfieldReverseStep<T, P, vecType, Aligned, true>
+	template<length_t L, typename T, glm::precision P, template<length_t, typename, precision> class vecType, bool Aligned>
+	struct compute_bitfieldReverseStep<L, T, P, vecType, Aligned, true>
 	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & v, T Mask, T Shift)
+		GLM_FUNC_QUALIFIER static vecType<L, T, P> call(vecType<L, T, P> const& v, T Mask, T Shift)
 		{
 			return (v & Mask) << Shift | (v & (~Mask)) >> Shift;
 		}
 	};
 
-	template <typename T, glm::precision P, template <typename, glm::precision> class vecType, bool Aligned, bool EXEC>
+	template<length_t L, typename T, glm::precision P, template<length_t, typename, precision> class vecType, bool Aligned, bool EXEC>
 	struct compute_bitfieldBitCountStep
 	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & v, T, T)
+		GLM_FUNC_QUALIFIER static vecType<L, T, P> call(vecType<L, T, P> const& v, T, T)
 		{
 			return v;
 		}
 	};
 
-	template <typename T, glm::precision P, template <typename, glm::precision> class vecType, bool Aligned>
-	struct compute_bitfieldBitCountStep<T, P, vecType, Aligned, true>
+	template<length_t L, typename T, glm::precision P, template<length_t, typename, precision> class vecType, bool Aligned>
+	struct compute_bitfieldBitCountStep<L, T, P, vecType, Aligned, true>
 	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & v, T Mask, T Shift)
+		GLM_FUNC_QUALIFIER static vecType<L, T, P> call(vecType<L, T, P> const& v, T Mask, T Shift)
 		{
 			return (v & Mask) + ((v >> Shift) & Mask);
 		}
 	};
 
-	template <typename genIUType, size_t Bits>
+	template<typename genIUType, size_t Bits>
 	struct compute_findLSB
 	{
 		GLM_FUNC_QUALIFIER static int call(genIUType Value)
@@ -79,7 +79,7 @@ namespace detail
 	};
 
 #	if GLM_HAS_BITSCAN_WINDOWS
-		template <typename genIUType>
+		template<typename genIUType>
 		struct compute_findLSB<genIUType, 32>
 		{
 			GLM_FUNC_QUALIFIER static int call(genIUType Value)
@@ -91,7 +91,7 @@ namespace detail
 		};
 
 #		if !((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_MODEL == GLM_MODEL_32))
-		template <typename genIUType>
+		template<typename genIUType>
 		struct compute_findLSB<genIUType, 64>
 		{
 			GLM_FUNC_QUALIFIER static int call(genIUType Value)
@@ -104,42 +104,42 @@ namespace detail
 #		endif
 #	endif//GLM_HAS_BITSCAN_WINDOWS
 
-	template <typename T, glm::precision P, template <class, glm::precision> class vecType, bool EXEC = true>
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType, bool EXEC = true>
 	struct compute_findMSB_step_vec
 	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x, T Shift)
+		GLM_FUNC_QUALIFIER static vecType<L, T, P> call(vecType<L, T, P> const & x, T Shift)
 		{
 			return x | (x >> Shift);
 		}
 	};
 
-	template <typename T, glm::precision P, template <typename, glm::precision> class vecType>
-	struct compute_findMSB_step_vec<T, P, vecType, false>
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	struct compute_findMSB_step_vec<L, T, P, vecType, false>
 	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x, T)
+		GLM_FUNC_QUALIFIER static vecType<L, T, P> call(vecType<L, T, P> const& x, T)
 		{
 			return x;
 		}
 	};
 
-	template <typename T, glm::precision P, template <typename, glm::precision> class vecType, int>
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType, int>
 	struct compute_findMSB_vec
 	{
-		GLM_FUNC_QUALIFIER static vecType<int, P> call(vecType<T, P> const & vec)
+		GLM_FUNC_QUALIFIER static vecType<L, int, P> call(vecType<L, T, P> const& v)
 		{
-			vecType<T, P> x(vec);
-			x = compute_findMSB_step_vec<T, P, vecType, sizeof(T) * 8 >=  8>::call(x, static_cast<T>( 1));
-			x = compute_findMSB_step_vec<T, P, vecType, sizeof(T) * 8 >=  8>::call(x, static_cast<T>( 2));
-			x = compute_findMSB_step_vec<T, P, vecType, sizeof(T) * 8 >=  8>::call(x, static_cast<T>( 4));
-			x = compute_findMSB_step_vec<T, P, vecType, sizeof(T) * 8 >= 16>::call(x, static_cast<T>( 8));
-			x = compute_findMSB_step_vec<T, P, vecType, sizeof(T) * 8 >= 32>::call(x, static_cast<T>(16));
-			x = compute_findMSB_step_vec<T, P, vecType, sizeof(T) * 8 >= 64>::call(x, static_cast<T>(32));
-			return vecType<int, P>(sizeof(T) * 8 - 1) - glm::bitCount(~x);
+			vecType<L, T, P> x(v);
+			x = compute_findMSB_step_vec<L, T, P, vecType, sizeof(T) * 8 >=  8>::call(x, static_cast<T>( 1));
+			x = compute_findMSB_step_vec<L, T, P, vecType, sizeof(T) * 8 >=  8>::call(x, static_cast<T>( 2));
+			x = compute_findMSB_step_vec<L, T, P, vecType, sizeof(T) * 8 >=  8>::call(x, static_cast<T>( 4));
+			x = compute_findMSB_step_vec<L, T, P, vecType, sizeof(T) * 8 >= 16>::call(x, static_cast<T>( 8));
+			x = compute_findMSB_step_vec<L, T, P, vecType, sizeof(T) * 8 >= 32>::call(x, static_cast<T>(16));
+			x = compute_findMSB_step_vec<L, T, P, vecType, sizeof(T) * 8 >= 64>::call(x, static_cast<T>(32));
+			return vecType<L, int, P>(sizeof(T) * 8 - 1) - glm::bitCount(~x);
 		}
 	};
 
 #	if GLM_HAS_BITSCAN_WINDOWS
-		template <typename genIUType>
+		template<typename genIUType>
 		GLM_FUNC_QUALIFIER int compute_findMSB_32(genIUType Value)
 		{
 			unsigned long Result(0);
@@ -147,17 +147,17 @@ namespace detail
 			return IsNotNull ? int(Result) : -1;
 		}
 
-		template <typename T, glm::precision P, template<typename, glm::precision> class vecType>
-		struct compute_findMSB_vec<T, P, vecType, 32>
+		template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+		struct compute_findMSB_vec<L, T, P, vecType, 32>
 		{
-			GLM_FUNC_QUALIFIER static vecType<int, P> call(vecType<T, P> const & x)
+			GLM_FUNC_QUALIFIER static vecType<L, int, P> call(vecType<L, T, P> const& x)
 			{
-				return detail::functor1<int, T, P, vecType>::call(compute_findMSB_32, x);
+				return detail::functor1<L, int, T, P>::call(compute_findMSB_32, x);
 			}
 		};
 
 #		if !((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_MODEL == GLM_MODEL_32))
-		template <typename genIUType>
+		template<typename genIUType>
 		GLM_FUNC_QUALIFIER int compute_findMSB_64(genIUType Value)
 		{
 			unsigned long Result(0);
@@ -165,12 +165,12 @@ namespace detail
 			return IsNotNull ? int(Result) : -1;
 		}
 
-		template <typename T, glm::precision P, template <class, glm::precision> class vecType>
-		struct compute_findMSB_vec<T, P, vecType, 64>
+		template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+		struct compute_findMSB_vec<L, T, P, vecType, 64>
 		{
-			GLM_FUNC_QUALIFIER static vecType<int, P> call(vecType<T, P> const & x)
+			GLM_FUNC_QUALIFIER static vecType<L, int, P> call(vecType<L, T, P> const& x)
 			{
-				return detail::functor1<int, T, P, vecType>::call(compute_findMSB_64, x);
+				return detail::functor1<L, int, T, P>::call(compute_findMSB_64, x);
 			}
 		};
 #		endif
@@ -186,13 +186,13 @@ namespace detail
 		return static_cast<uint32>(Value64 % (Max32 + static_cast<uint64>(1)));
 	}
 
-	template <precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<uint, P> uaddCarry(vecType<uint, P> const & x, vecType<uint, P> const & y, vecType<uint, P> & Carry)
+	template<length_t L, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, uint, P> uaddCarry(vecType<L, uint, P> const& x, vecType<L, uint, P> const& y, vecType<L, uint, P>& Carry)
 	{
-		vecType<uint64, P> Value64(vecType<uint64, P>(x) + vecType<uint64, P>(y));
-		vecType<uint64, P> Max32((static_cast<uint64>(1) << static_cast<uint64>(32)) - static_cast<uint64>(1));
-		Carry = mix(vecType<uint32, P>(0), vecType<uint32, P>(1), greaterThan(Value64, Max32));
-		return vecType<uint32,P>(Value64 % (Max32 + static_cast<uint64>(1)));
+		vecType<L, uint64, P> Value64(vecType<L, uint64, P>(x) + vecType<L, uint64, P>(y));
+		vecType<L, uint64, P> Max32((static_cast<uint64>(1) << static_cast<uint64>(32)) - static_cast<uint64>(1));
+		Carry = mix(vecType<L, uint32, P>(0), vecType<L, uint32, P>(1), greaterThan(Value64, Max32));
+		return vecType<L, uint32,P>(Value64 % (Max32 + static_cast<uint64>(1)));
 	}
 
 	// usubBorrow
@@ -207,12 +207,12 @@ namespace detail
 			return static_cast<uint32>((static_cast<int64>(1) << static_cast<int64>(32)) + (static_cast<int64>(y) - static_cast<int64>(x)));
 	}
 
-	template <precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<uint, P> usubBorrow(vecType<uint, P> const & x, vecType<uint, P> const & y, vecType<uint, P> & Borrow)
+	template<length_t L, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, uint, P> usubBorrow(vecType<L, uint, P> const& x, vecType<L, uint, P> const& y, vecType<L, uint, P>& Borrow)
 	{
-		Borrow = mix(vecType<uint, P>(1), vecType<uint, P>(0), greaterThanEqual(x, y));
-		vecType<uint, P> const YgeX(y - x);
-		vecType<uint, P> const XgeY(vecType<uint32, P>((static_cast<int64>(1) << static_cast<int64>(32)) + (vecType<int64, P>(y) - vecType<int64, P>(x))));
+		Borrow = mix(vecType<L, uint, P>(1), vecType<L, uint, P>(0), greaterThanEqual(x, y));
+		vecType<L, uint, P> const YgeX(y - x);
+		vecType<L, uint, P> const XgeY(vecType<L, uint32, P>((static_cast<int64>(1) << static_cast<int64>(32)) + (vecType<L, int64, P>(y) - vecType<L, int64, P>(x))));
 		return mix(XgeY, YgeX, greaterThanEqual(y, x));
 	}
 
@@ -226,18 +226,18 @@ namespace detail
 		lsb = static_cast<uint>(Value64);
 	}
 
-	template <precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER void umulExtended(vecType<uint, P> const & x, vecType<uint, P> const & y, vecType<uint, P> & msb, vecType<uint, P> & lsb)
+	template<length_t L, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER void umulExtended(vecType<L, uint, P> const& x, vecType<L, uint, P> const& y, vecType<L, uint, P>& msb, vecType<L, uint, P>& lsb)
 	{
 		GLM_STATIC_ASSERT(sizeof(uint) == sizeof(uint32), "uint and uint32 size mismatch");
 
-		vecType<uint64, P> Value64(vecType<uint64, P>(x) * vecType<uint64, P>(y));
-		msb = vecType<uint32, P>(Value64 >> static_cast<uint64>(32));
-		lsb = vecType<uint32, P>(Value64);
+		vecType<L, uint64, P> Value64(vecType<L, uint64, P>(x) * vecType<L, uint64, P>(y));
+		msb = vecType<L, uint32, P>(Value64 >> static_cast<uint64>(32));
+		lsb = vecType<L, uint32, P>(Value64);
 	}
 
 	// imulExtended
-	GLM_FUNC_QUALIFIER void imulExtended(int x, int y, int & msb, int & lsb)
+	GLM_FUNC_QUALIFIER void imulExtended(int x, int y, int& msb, int& lsb)
 	{
 		GLM_STATIC_ASSERT(sizeof(int) == sizeof(int32), "int and int32 size mismatch");
 
@@ -246,25 +246,25 @@ namespace detail
 		lsb = static_cast<int>(Value64);
 	}
 
-	template <precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER void imulExtended(vecType<int, P> const & x, vecType<int, P> const & y, vecType<int, P> & msb, vecType<int, P> & lsb)
+	template<length_t L, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER void imulExtended(vecType<L, int, P> const& x, vecType<L, int, P> const& y, vecType<L, int, P>& msb, vecType<L, int, P>& lsb)
 	{
 		GLM_STATIC_ASSERT(sizeof(int) == sizeof(int32), "int and int32 size mismatch");
 
-		vecType<int64, P> Value64(vecType<int64, P>(x) * vecType<int64, P>(y));
-		lsb = vecType<int32, P>(Value64 & static_cast<int64>(0xFFFFFFFF));
-		msb = vecType<int32, P>((Value64 >> static_cast<int64>(32)) & static_cast<int64>(0xFFFFFFFF));
+		vecType<L, int64, P> Value64(vecType<L, int64, P>(x) * vecType<L, int64, P>(y));
+		lsb = vecType<L, int32, P>(Value64 & static_cast<int64>(0xFFFFFFFF));
+		msb = vecType<L, int32, P>((Value64 >> static_cast<int64>(32)) & static_cast<int64>(0xFFFFFFFF));
 	}
 
 	// bitfieldExtract
-	template <typename genIUType>
+	template<typename genIUType>
 	GLM_FUNC_QUALIFIER genIUType bitfieldExtract(genIUType Value, int Offset, int Bits)
 	{
-		return bitfieldExtract(tvec1<genIUType>(Value), Offset, Bits).x;
+		return bitfieldExtract(vec<1, genIUType>(Value), Offset, Bits).x;
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> bitfieldExtract(vecType<T, P> const & Value, int Offset, int Bits)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> bitfieldExtract(vecType<L, T, P> const& Value, int Offset, int Bits)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_integer, "'bitfieldExtract' only accept integer inputs");
 
@@ -272,14 +272,14 @@ namespace detail
 	}
 
 	// bitfieldInsert
-	template <typename genIUType>
+	template<typename genIUType>
 	GLM_FUNC_QUALIFIER genIUType bitfieldInsert(genIUType const & Base, genIUType const & Insert, int Offset, int Bits)
 	{
-		return bitfieldInsert(tvec1<genIUType>(Base), tvec1<genIUType>(Insert), Offset, Bits).x;
+		return bitfieldInsert(vec<1, genIUType>(Base), vec<1, genIUType>(Insert), Offset, Bits).x;
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> bitfieldInsert(vecType<T, P> const & Base, vecType<T, P> const & Insert, int Offset, int Bits)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> bitfieldInsert(vecType<L, T, P> const& Base, vecType<L, T, P> const& Insert, int Offset, int Bits)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_integer, "'bitfieldInsert' only accept integer values");
 
@@ -288,54 +288,54 @@ namespace detail
 	}
 
 	// bitfieldReverse
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER genType bitfieldReverse(genType x)
 	{
-		return bitfieldReverse(glm::tvec1<genType, glm::defaultp>(x)).x;
+		return bitfieldReverse(glm::vec<1, genType, glm::defaultp>(x)).x;
 	}
 
-	template <typename T, glm::precision P, template <typename, glm::precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> bitfieldReverse(vecType<T, P> const & v)
+	template<length_t L, typename T, glm::precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> bitfieldReverse(vecType<L, T, P> const& v)
 	{
-		vecType<T, P> x(v);
-		x = detail::compute_bitfieldReverseStep<T, P, vecType, detail::is_aligned<P>::value, sizeof(T) * 8>=  2>::call(x, T(0x5555555555555555ull), static_cast<T>( 1));
-		x = detail::compute_bitfieldReverseStep<T, P, vecType, detail::is_aligned<P>::value, sizeof(T) * 8>=  4>::call(x, T(0x3333333333333333ull), static_cast<T>( 2));
-		x = detail::compute_bitfieldReverseStep<T, P, vecType, detail::is_aligned<P>::value, sizeof(T) * 8>=  8>::call(x, T(0x0F0F0F0F0F0F0F0Full), static_cast<T>( 4));
-		x = detail::compute_bitfieldReverseStep<T, P, vecType, detail::is_aligned<P>::value, sizeof(T) * 8>= 16>::call(x, T(0x00FF00FF00FF00FFull), static_cast<T>( 8));
-		x = detail::compute_bitfieldReverseStep<T, P, vecType, detail::is_aligned<P>::value, sizeof(T) * 8>= 32>::call(x, T(0x0000FFFF0000FFFFull), static_cast<T>(16));
-		x = detail::compute_bitfieldReverseStep<T, P, vecType, detail::is_aligned<P>::value, sizeof(T) * 8>= 64>::call(x, T(0x00000000FFFFFFFFull), static_cast<T>(32));
+		vecType<L, T, P> x(v);
+		x = detail::compute_bitfieldReverseStep<L, T, P, vecType, detail::is_aligned<P>::value, sizeof(T) * 8>=  2>::call(x, T(0x5555555555555555ull), static_cast<T>( 1));
+		x = detail::compute_bitfieldReverseStep<L, T, P, vecType, detail::is_aligned<P>::value, sizeof(T) * 8>=  4>::call(x, T(0x3333333333333333ull), static_cast<T>( 2));
+		x = detail::compute_bitfieldReverseStep<L, T, P, vecType, detail::is_aligned<P>::value, sizeof(T) * 8>=  8>::call(x, T(0x0F0F0F0F0F0F0F0Full), static_cast<T>( 4));
+		x = detail::compute_bitfieldReverseStep<L, T, P, vecType, detail::is_aligned<P>::value, sizeof(T) * 8>= 16>::call(x, T(0x00FF00FF00FF00FFull), static_cast<T>( 8));
+		x = detail::compute_bitfieldReverseStep<L, T, P, vecType, detail::is_aligned<P>::value, sizeof(T) * 8>= 32>::call(x, T(0x0000FFFF0000FFFFull), static_cast<T>(16));
+		x = detail::compute_bitfieldReverseStep<L, T, P, vecType, detail::is_aligned<P>::value, sizeof(T) * 8>= 64>::call(x, T(0x00000000FFFFFFFFull), static_cast<T>(32));
 		return x;
 	}
 
 	// bitCount
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER int bitCount(genType x)
 	{
-		return bitCount(glm::tvec1<genType, glm::defaultp>(x)).x;
+		return bitCount(glm::vec<1, genType, glm::defaultp>(x)).x;
 	}
 
-	template <typename T, glm::precision P, template <typename, glm::precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<int, P> bitCount(vecType<T, P> const & v)
+	template<length_t L, typename T, glm::precision P, template<length_t, typename, glm::precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, int, P> bitCount(vecType<L, T, P> const& v)
 	{
 	#if GLM_COMPILER & GLM_COMPILER_VC
 	#pragma warning(push)
 	#pragma warning(disable : 4310) //cast truncates constant value
 	#endif
-		vecType<typename detail::make_unsigned<T>::type, P> x(*reinterpret_cast<vecType<typename detail::make_unsigned<T>::type, P> const *>(&v));
-		x = detail::compute_bitfieldBitCountStep<typename detail::make_unsigned<T>::type, P, vecType, detail::is_aligned<P>::value, sizeof(T) * 8>=  2>::call(x, typename detail::make_unsigned<T>::type(0x5555555555555555ull), typename detail::make_unsigned<T>::type( 1));
-		x = detail::compute_bitfieldBitCountStep<typename detail::make_unsigned<T>::type, P, vecType, detail::is_aligned<P>::value, sizeof(T) * 8>=  4>::call(x, typename detail::make_unsigned<T>::type(0x3333333333333333ull), typename detail::make_unsigned<T>::type( 2));
-		x = detail::compute_bitfieldBitCountStep<typename detail::make_unsigned<T>::type, P, vecType, detail::is_aligned<P>::value, sizeof(T) * 8>=  8>::call(x, typename detail::make_unsigned<T>::type(0x0F0F0F0F0F0F0F0Full), typename detail::make_unsigned<T>::type( 4));
-		x = detail::compute_bitfieldBitCountStep<typename detail::make_unsigned<T>::type, P, vecType, detail::is_aligned<P>::value, sizeof(T) * 8>= 16>::call(x, typename detail::make_unsigned<T>::type(0x00FF00FF00FF00FFull), typename detail::make_unsigned<T>::type( 8));
-		x = detail::compute_bitfieldBitCountStep<typename detail::make_unsigned<T>::type, P, vecType, detail::is_aligned<P>::value, sizeof(T) * 8>= 32>::call(x, typename detail::make_unsigned<T>::type(0x0000FFFF0000FFFFull), typename detail::make_unsigned<T>::type(16));
-		x = detail::compute_bitfieldBitCountStep<typename detail::make_unsigned<T>::type, P, vecType, detail::is_aligned<P>::value, sizeof(T) * 8>= 64>::call(x, typename detail::make_unsigned<T>::type(0x00000000FFFFFFFFull), typename detail::make_unsigned<T>::type(32));
-		return vecType<int, P>(x);
+		vecType<L, typename detail::make_unsigned<T>::type, P> x(*reinterpret_cast<vecType<L, typename detail::make_unsigned<T>::type, P> const *>(&v));
+		x = detail::compute_bitfieldBitCountStep<L, typename detail::make_unsigned<T>::type, P, vecType, detail::is_aligned<P>::value, sizeof(T) * 8>=  2>::call(x, typename detail::make_unsigned<T>::type(0x5555555555555555ull), typename detail::make_unsigned<T>::type( 1));
+		x = detail::compute_bitfieldBitCountStep<L, typename detail::make_unsigned<T>::type, P, vecType, detail::is_aligned<P>::value, sizeof(T) * 8>=  4>::call(x, typename detail::make_unsigned<T>::type(0x3333333333333333ull), typename detail::make_unsigned<T>::type( 2));
+		x = detail::compute_bitfieldBitCountStep<L, typename detail::make_unsigned<T>::type, P, vecType, detail::is_aligned<P>::value, sizeof(T) * 8>=  8>::call(x, typename detail::make_unsigned<T>::type(0x0F0F0F0F0F0F0F0Full), typename detail::make_unsigned<T>::type( 4));
+		x = detail::compute_bitfieldBitCountStep<L, typename detail::make_unsigned<T>::type, P, vecType, detail::is_aligned<P>::value, sizeof(T) * 8>= 16>::call(x, typename detail::make_unsigned<T>::type(0x00FF00FF00FF00FFull), typename detail::make_unsigned<T>::type( 8));
+		x = detail::compute_bitfieldBitCountStep<L, typename detail::make_unsigned<T>::type, P, vecType, detail::is_aligned<P>::value, sizeof(T) * 8>= 32>::call(x, typename detail::make_unsigned<T>::type(0x0000FFFF0000FFFFull), typename detail::make_unsigned<T>::type(16));
+		x = detail::compute_bitfieldBitCountStep<L, typename detail::make_unsigned<T>::type, P, vecType, detail::is_aligned<P>::value, sizeof(T) * 8>= 64>::call(x, typename detail::make_unsigned<T>::type(0x00000000FFFFFFFFull), typename detail::make_unsigned<T>::type(32));
+		return vecType<L, int, P>(x);
 	#if GLM_COMPILER & GLM_COMPILER_VC
 	#pragma warning(pop)
 	#endif
 	}
 
 	// findLSB
-	template <typename genIUType>
+	template<typename genIUType>
 	GLM_FUNC_QUALIFIER int findLSB(genIUType Value)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'findLSB' only accept integer values");
@@ -343,29 +343,29 @@ namespace detail
 		return detail::compute_findLSB<genIUType, sizeof(genIUType) * 8>::call(Value);
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<int, P> findLSB(vecType<T, P> const & x)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, int, P> findLSB(vecType<L, T, P> const& x)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_integer, "'findLSB' only accept integer values");
 
-		return detail::functor1<int, T, P, vecType>::call(findLSB, x);
+		return detail::functor1<L, int, T, P>::call(findLSB, x);
 	}
 
 	// findMSB
-	template <typename genIUType>
-	GLM_FUNC_QUALIFIER int findMSB(genIUType x)
+	template<typename genIUType>
+	GLM_FUNC_QUALIFIER int findMSB(genIUType v)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'findMSB' only accept integer values");
 
-		return findMSB(tvec1<genIUType>(x)).x;
+		return findMSB(vec<1, genIUType>(v)).x;
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<int, P> findMSB(vecType<T, P> const & x)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, int, P> findMSB(vecType<L, T, P> const& v)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_integer, "'findMSB' only accept integer values");
 
-		return detail::compute_findMSB_vec<T, P, vecType, sizeof(T) * 8>::call(x);
+		return detail::compute_findMSB_vec<L, T, P, vecType, sizeof(T) * 8>::call(v);
 	}
 }//namespace glm
 
diff --git a/glm/detail/func_integer_simd.inl b/glm/detail/func_integer_simd.inl
index 61758604..ddff75ba 100644
--- a/glm/detail/func_integer_simd.inl
+++ b/glm/detail/func_integer_simd.inl
@@ -8,10 +8,10 @@
 namespace glm{
 namespace detail
 {
-	template <glm::precision P>
-	struct compute_bitfieldReverseStep<uint32, P, tvec4, true, true>
+	template<glm::precision P>
+	struct compute_bitfieldReverseStep<4, uint32, P, vec, true, true>
 	{
-		GLM_FUNC_QUALIFIER static tvec4<uint32, P> call(tvec4<uint32, P> const & v, uint32 Mask, uint32 Shift)
+		GLM_FUNC_QUALIFIER static vec<4, uint32, P> call(vec<4, uint32, P> const & v, uint32 Mask, uint32 Shift)
 		{
 			__m128i const set0 = v.data;
 
@@ -29,10 +29,10 @@ namespace detail
 		}
 	};
 
-	template <glm::precision P>
-	struct compute_bitfieldBitCountStep<uint32, P, tvec4, true, true>
+	template<glm::precision P>
+	struct compute_bitfieldBitCountStep<4, uint32, P, vec, true, true>
 	{
-		GLM_FUNC_QUALIFIER static tvec4<uint32, P> call(tvec4<uint32, P> const & v, uint32 Mask, uint32 Shift)
+		GLM_FUNC_QUALIFIER static vec<4, uint32, P> call(vec<4, uint32, P> const & v, uint32 Mask, uint32 Shift)
 		{
 			__m128i const set0 = v.data;
 
@@ -48,14 +48,14 @@ namespace detail
 }//namespace detail
 
 #	if GLM_ARCH & GLM_ARCH_AVX_BIT
-	template <>
+	template<>
 	GLM_FUNC_QUALIFIER int bitCount(uint32 x)
 	{
 		return _mm_popcnt_u32(x);
 	}
 
 #	if(GLM_MODEL == GLM_MODEL_64)
-	template <>
+	template<>
 	GLM_FUNC_QUALIFIER int bitCount(uint64 x)
 	{
 		return static_cast<int>(_mm_popcnt_u64(x));
diff --git a/glm/detail/func_matrix.hpp b/glm/detail/func_matrix.hpp
index 9be34495..b47efbe4 100644
--- a/glm/detail/func_matrix.hpp
+++ b/glm/detail/func_matrix.hpp
@@ -34,58 +34,58 @@
 namespace glm{
 namespace detail
 {
-	template <typename T, precision P>
-	struct outerProduct_trait<T, P, tvec2, tvec2>
+	template<typename T, precision P>
+	struct outerProduct_trait<2, 2, T, P, vec, vec>
 	{
-		typedef tmat2x2<T, P> type;
+		typedef mat<2, 2, T, P> type;
 	};
 
-	template <typename T, precision P>
-	struct outerProduct_trait<T, P, tvec2, tvec3>
+	template<typename T, precision P>
+	struct outerProduct_trait<2, 3, T, P, vec, vec>
 	{
-		typedef tmat3x2<T, P> type;
+		typedef mat<3, 2, T, P> type;
 	};
 
-	template <typename T, precision P>
-	struct outerProduct_trait<T, P, tvec2, tvec4>
+	template<typename T, precision P>
+	struct outerProduct_trait<2, 4, T, P, vec, vec>
 	{
-		typedef tmat4x2<T, P> type;
+		typedef mat<4, 2, T, P> type;
 	};
 
-	template <typename T, precision P>
-	struct outerProduct_trait<T, P, tvec3, tvec2>
+	template<typename T, precision P>
+	struct outerProduct_trait<3, 2, T, P, vec, vec>
 	{
-		typedef tmat2x3<T, P> type;
+		typedef mat<2, 3, T, P> type;
 	};
 
-	template <typename T, precision P>
-	struct outerProduct_trait<T, P, tvec3, tvec3>
+	template<typename T, precision P>
+	struct outerProduct_trait<3, 3, T, P, vec, vec>
 	{
-		typedef tmat3x3<T, P> type;
+		typedef mat<3, 3, T, P> type;
 	};
 
-	template <typename T, precision P>
-	struct outerProduct_trait<T, P, tvec3, tvec4>
+	template<typename T, precision P>
+	struct outerProduct_trait<3, 4, T, P, vec, vec>
 	{
-		typedef tmat4x3<T, P> type;
+		typedef mat<4, 3, T, P> type;
 	};
 
-	template <typename T, precision P>
-	struct outerProduct_trait<T, P, tvec4, tvec2>
+	template<typename T, precision P>
+	struct outerProduct_trait<4, 2, T, P, vec, vec>
 	{
-		typedef tmat2x4<T, P> type;
+		typedef mat<2, 4, T, P> type;
 	};
 
-	template <typename T, precision P>
-	struct outerProduct_trait<T, P, tvec4, tvec3>
+	template<typename T, precision P>
+	struct outerProduct_trait<4, 3, T, P, vec, vec>
 	{
-		typedef tmat3x4<T, P> type;
+		typedef mat<3, 4, T, P> type;
 	};
 
-	template <typename T, precision P>
-	struct outerProduct_trait<T, P, tvec4, tvec4>
+	template<typename T, precision P>
+	struct outerProduct_trait<4, 4, T, P, vec, vec>
 	{
-		typedef tmat4x4<T, P> type;
+		typedef mat<4, 4, T, P> type;
 	};
 
 }//namespace detail
@@ -100,7 +100,7 @@ namespace detail
 	///
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/matrixCompMult.xml">GLSL matrixCompMult man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>
-	template <typename T, precision P, template <typename, precision> class matType>
+	template<typename T, precision P, template<typename, precision> class matType>
 	GLM_FUNC_DECL matType<T, P> matrixCompMult(matType<T, P> const & x, matType<T, P> const & y);
 
 	/// Treats the first parameter c as a column vector
@@ -111,8 +111,8 @@ namespace detail
 	///
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/outerProduct.xml">GLSL outerProduct man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>
-	template <typename T, precision P, template <typename, precision> class vecTypeA, template <typename, precision> class vecTypeB>
-	GLM_FUNC_DECL typename detail::outerProduct_trait<T, P, vecTypeA, vecTypeB>::type outerProduct(vecTypeA<T, P> const & c, vecTypeB<T, P> const & r);
+	template<int DA, int DB, typename T, precision P, template<length_t, typename, precision> class vecTypeA, template<length_t, typename, precision> class vecTypeB>
+	GLM_FUNC_DECL typename detail::outerProduct_trait<DA, DB, T, P, vecTypeA, vecTypeB>::type outerProduct(vecTypeA<DA, T, P> const & c, vecTypeB<DB, T, P> const & r);
 
 	/// Returns the transposed matrix of x
 	/// 
@@ -121,7 +121,7 @@ namespace detail
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/transpose.xml">GLSL transpose man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>
 #	if((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC11))
-		template <typename T, precision P, template <typename, precision> class matType>
+		template<typename T, precision P, template<typename, precision> class matType>
 		GLM_FUNC_DECL typename matType<T, P>::transpose_type transpose(matType<T, P> const & x);
 #	endif
 	
@@ -131,7 +131,7 @@ namespace detail
 	///
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/determinant.xml">GLSL determinant man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>	
-	template <typename T, precision P, template <typename, precision> class matType>
+	template<typename T, precision P, template<typename, precision> class matType>
 	GLM_FUNC_DECL T determinant(matType<T, P> const & m);
 
 	/// Return the inverse of a squared matrix.
@@ -140,7 +140,7 @@ namespace detail
 	///
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/inverse.xml">GLSL inverse man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>	 
-	template <typename T, precision P, template <typename, precision> class matType>
+	template<typename T, precision P, template<typename, precision> class matType>
 	GLM_FUNC_DECL matType<T, P> inverse(matType<T, P> const & m);
 
 	/// @}
diff --git a/glm/detail/func_matrix.inl b/glm/detail/func_matrix.inl
index 6d1746be..aa605fc1 100644
--- a/glm/detail/func_matrix.inl
+++ b/glm/detail/func_matrix.inl
@@ -7,27 +7,27 @@
 namespace glm{
 namespace detail
 {
-	template <template <typename, precision> class matType, typename T, precision P, bool Aligned>
+	template<template<length_t, length_t, typename, precision> class matType, length_t C, length_t R, typename T, precision P, bool Aligned>
 	struct compute_matrixCompMult
 	{
-		GLM_FUNC_QUALIFIER static matType<T, P> call(matType<T, P> const& x, matType<T, P> const& y)
+		GLM_FUNC_QUALIFIER static matType<C, R, T, P> call(matType<C, R, T, P> const& x, matType<C, R, T, P> const& y)
 		{
-			matType<T, P> result(uninitialize);
+			matType<C, R, T, P> result(uninitialize);
 			for(length_t i = 0; i < result.length(); ++i)
 				result[i] = x[i] * y[i];
 			return result;
 		}
 	};
 
-	template <template <class, precision> class matType, typename T, precision P, bool Aligned>
+	template<template<length_t, length_t, typename, precision> class matType, length_t C, length_t R, typename T, precision P, bool Aligned>
 	struct compute_transpose{};
 
-	template <typename T, precision P, bool Aligned>
-	struct compute_transpose<tmat2x2, T, P, Aligned>
+	template<typename T, precision P, bool Aligned>
+	struct compute_transpose<mat, 2, 2, T, P, Aligned>
 	{
-		GLM_FUNC_QUALIFIER static tmat2x2<T, P> call(tmat2x2<T, P> const & m)
+		GLM_FUNC_QUALIFIER static mat<2, 2, T, P> call(mat<2, 2, T, P> const& m)
 		{
-			tmat2x2<T, P> result(uninitialize);
+			mat<2, 2, T, P> result(uninitialize);
 			result[0][0] = m[0][0];
 			result[0][1] = m[1][0];
 			result[1][0] = m[0][1];
@@ -36,12 +36,12 @@ namespace detail
 		}
 	};
 
-	template <typename T, precision P, bool Aligned>
-	struct compute_transpose<tmat2x3, T, P, Aligned>
+	template<typename T, precision P, bool Aligned>
+	struct compute_transpose<mat, 2, 3, T, P, Aligned>
 	{
-		GLM_FUNC_QUALIFIER static tmat3x2<T, P> call(tmat2x3<T, P> const & m)
+		GLM_FUNC_QUALIFIER static mat<3, 2, T, P> call(mat<2, 3, T, P> const& m)
 		{
-			tmat3x2<T, P> result(uninitialize);
+			mat<3,2, T, P> result(uninitialize);
 			result[0][0] = m[0][0];
 			result[0][1] = m[1][0];
 			result[1][0] = m[0][1];
@@ -52,12 +52,12 @@ namespace detail
 		}
 	};
 
-	template <typename T, precision P, bool Aligned>
-	struct compute_transpose<tmat2x4, T, P, Aligned>
+	template<typename T, precision P, bool Aligned>
+	struct compute_transpose<mat, 2, 4, T, P, Aligned>
 	{
-		GLM_FUNC_QUALIFIER static tmat4x2<T, P> call(tmat2x4<T, P> const & m)
+		GLM_FUNC_QUALIFIER static mat<4, 2, T, P> call(mat<2, 4, T, P> const& m)
 		{
-			tmat4x2<T, P> result(uninitialize);
+			mat<4, 2, T, P> result(uninitialize);
 			result[0][0] = m[0][0];
 			result[0][1] = m[1][0];
 			result[1][0] = m[0][1];
@@ -70,12 +70,12 @@ namespace detail
 		}
 	};
 
-	template <typename T, precision P, bool Aligned>
-	struct compute_transpose<tmat3x2, T, P, Aligned>
+	template<typename T, precision P, bool Aligned>
+	struct compute_transpose<mat, 3, 2, T, P, Aligned>
 	{
-		GLM_FUNC_QUALIFIER static tmat2x3<T, P> call(tmat3x2<T, P> const & m)
+		GLM_FUNC_QUALIFIER static mat<2, 3, T, P> call(mat<3, 2, T, P> const& m)
 		{
-			tmat2x3<T, P> result(uninitialize);
+			mat<2, 3, T, P> result(uninitialize);
 			result[0][0] = m[0][0];
 			result[0][1] = m[1][0];
 			result[0][2] = m[2][0];
@@ -86,12 +86,12 @@ namespace detail
 		}
 	};
 
-	template <typename T, precision P, bool Aligned>
-	struct compute_transpose<tmat3x3, T, P, Aligned>
+	template<typename T, precision P, bool Aligned>
+	struct compute_transpose<mat, 3, 3, T, P, Aligned>
 	{
-		GLM_FUNC_QUALIFIER static tmat3x3<T, P> call(tmat3x3<T, P> const & m)
+		GLM_FUNC_QUALIFIER static mat<3, 3, T, P> call(mat<3, 3, T, P> const& m)
 		{
-			tmat3x3<T, P> result(uninitialize);
+			mat<3, 3, T, P> result(uninitialize);
 			result[0][0] = m[0][0];
 			result[0][1] = m[1][0];
 			result[0][2] = m[2][0];
@@ -107,12 +107,12 @@ namespace detail
 		}
 	};
 
-	template <typename T, precision P, bool Aligned>
-	struct compute_transpose<tmat3x4, T, P, Aligned>
+	template<typename T, precision P, bool Aligned>
+	struct compute_transpose<mat, 3, 4, T, P, Aligned>
 	{
-		GLM_FUNC_QUALIFIER static tmat4x3<T, P> call(tmat3x4<T, P> const & m)
+		GLM_FUNC_QUALIFIER static mat<4, 3, T, P> call(mat<3, 4, T, P> const& m)
 		{
-			tmat4x3<T, P> result(uninitialize);
+			mat<4, 3, T, P> result(uninitialize);
 			result[0][0] = m[0][0];
 			result[0][1] = m[1][0];
 			result[0][2] = m[2][0];
@@ -129,12 +129,12 @@ namespace detail
 		}
 	};
 
-	template <typename T, precision P, bool Aligned>
-	struct compute_transpose<tmat4x2, T, P, Aligned>
+	template<typename T, precision P, bool Aligned>
+	struct compute_transpose<mat, 4, 2, T, P, Aligned>
 	{
-		GLM_FUNC_QUALIFIER static tmat2x4<T, P> call(tmat4x2<T, P> const & m)
+		GLM_FUNC_QUALIFIER static mat<2, 4, T, P> call(mat<4, 2, T, P> const& m)
 		{
-			tmat2x4<T, P> result(uninitialize);
+			mat<2, 4, T, P> result(uninitialize);
 			result[0][0] = m[0][0];
 			result[0][1] = m[1][0];
 			result[0][2] = m[2][0];
@@ -147,12 +147,12 @@ namespace detail
 		}
 	};
 
-	template <typename T, precision P, bool Aligned>
-	struct compute_transpose<tmat4x3, T, P, Aligned>
+	template<typename T, precision P, bool Aligned>
+	struct compute_transpose<mat, 4, 3, T, P, Aligned>
 	{
-		GLM_FUNC_QUALIFIER static tmat3x4<T, P> call(tmat4x3<T, P> const & m)
+		GLM_FUNC_QUALIFIER static mat<3, 4, T, P> call(mat<4, 3, T, P> const& m)
 		{
-			tmat3x4<T, P> result(uninitialize);
+			mat<3, 4, T, P> result(uninitialize);
 			result[0][0] = m[0][0];
 			result[0][1] = m[1][0];
 			result[0][2] = m[2][0];
@@ -169,12 +169,12 @@ namespace detail
 		}
 	};
 
-	template <typename T, precision P, bool Aligned>
-	struct compute_transpose<tmat4x4, T, P, Aligned>
+	template<typename T, precision P, bool Aligned>
+	struct compute_transpose<mat, 4, 4, T, P, Aligned>
 	{
-		GLM_FUNC_QUALIFIER static tmat4x4<T, P> call(tmat4x4<T, P> const & m)
+		GLM_FUNC_QUALIFIER static mat<4, 4, T, P> call(mat<4, 4, T, P> const& m)
 		{
-			tmat4x4<T, P> result(uninitialize);
+			mat<4, 4, T, P> result(uninitialize);
 			result[0][0] = m[0][0];
 			result[0][1] = m[1][0];
 			result[0][2] = m[2][0];
@@ -198,22 +198,22 @@ namespace detail
 		}
 	};
 
-	template <template <typename, precision> class matType, typename T, precision P, bool Aligned>
+	template<template<length_t, length_t, typename, precision> class matType, length_t C, length_t R, typename T, precision P, bool Aligned>
 	struct compute_determinant{};
 
-	template <typename T, precision P, bool Aligned>
-	struct compute_determinant<tmat2x2, T, P, Aligned>
+	template<typename T, precision P, bool Aligned>
+	struct compute_determinant<mat, 2, 2, T, P, Aligned>
 	{
-		GLM_FUNC_QUALIFIER static T call(tmat2x2<T, P> const & m)
+		GLM_FUNC_QUALIFIER static T call(mat<2, 2, T, P> const& m)
 		{
 			return m[0][0] * m[1][1] - m[1][0] * m[0][1];
 		}
 	};
 
-	template <typename T, precision P, bool Aligned>
-	struct compute_determinant<tmat3x3, T, P, Aligned>
+	template<typename T, precision P, bool Aligned>
+	struct compute_determinant<mat, 3, 3, T, P, Aligned>
 	{
-		GLM_FUNC_QUALIFIER static T call(tmat3x3<T, P> const & m)
+		GLM_FUNC_QUALIFIER static T call(mat<3, 3, T, P> const& m)
 		{
 			return
 				+ m[0][0] * (m[1][1] * m[2][2] - m[2][1] * m[1][2])
@@ -222,10 +222,10 @@ namespace detail
 		}
 	};
 
-	template <typename T, precision P, bool Aligned>
-	struct compute_determinant<tmat4x4, T, P, Aligned>
+	template<typename T, precision P, bool Aligned>
+	struct compute_determinant<mat, 4, 4, T, P, Aligned>
 	{
-		GLM_FUNC_QUALIFIER static T call(tmat4x4<T, P> const & m)
+		GLM_FUNC_QUALIFIER static T call(mat<4, 4, T, P> const& m)
 		{
 			T SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
 			T SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
@@ -234,7 +234,7 @@ namespace detail
 			T SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
 			T SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
 
-			tvec4<T, P> DetCof(
+			vec<4, T, P> DetCof(
 				+ (m[1][1] * SubFactor00 - m[1][2] * SubFactor01 + m[1][3] * SubFactor02),
 				- (m[1][0] * SubFactor00 - m[1][2] * SubFactor03 + m[1][3] * SubFactor04),
 				+ (m[1][0] * SubFactor01 - m[1][1] * SubFactor03 + m[1][3] * SubFactor05),
@@ -246,19 +246,19 @@ namespace detail
 		}
 	};
 
-	template <template <typename, precision> class matType, typename T, precision P, bool Aligned>
+	template<template<length_t, length_t, typename, precision> class matType, length_t C, length_t R, typename T, precision P, bool Aligned>
 	struct compute_inverse{};
 
-	template <typename T, precision P, bool Aligned>
-	struct compute_inverse<tmat2x2, T, P, Aligned>
+	template<typename T, precision P, bool Aligned>
+	struct compute_inverse<mat, 2, 2, T, P, Aligned>
 	{
-		GLM_FUNC_QUALIFIER static tmat2x2<T, P> call(tmat2x2<T, P> const& m)
+		GLM_FUNC_QUALIFIER static mat<2, 2, T, P> call(mat<2, 2, T, P> const& m)
 		{
 			T OneOverDeterminant = static_cast<T>(1) / (
 				+ m[0][0] * m[1][1]
 				- m[1][0] * m[0][1]);
 
-			tmat2x2<T, P> Inverse(
+			mat<2, 2, T, P> Inverse(
 				+ m[1][1] * OneOverDeterminant,
 				- m[0][1] * OneOverDeterminant,
 				- m[1][0] * OneOverDeterminant,
@@ -268,17 +268,17 @@ namespace detail
 		}
 	};
 
-	template <typename T, precision P, bool Aligned>
-	struct compute_inverse<tmat3x3, T, P, Aligned>
+	template<typename T, precision P, bool Aligned>
+	struct compute_inverse<mat, 3, 3, T, P, Aligned>
 	{
-		GLM_FUNC_QUALIFIER static tmat3x3<T, P> call(tmat3x3<T, P> const& m)
+		GLM_FUNC_QUALIFIER static mat<3, 3, T, P> call(mat<3, 3, T, P> const& m)
 		{
 			T OneOverDeterminant = static_cast<T>(1) / (
 				+ m[0][0] * (m[1][1] * m[2][2] - m[2][1] * m[1][2])
 				- m[1][0] * (m[0][1] * m[2][2] - m[2][1] * m[0][2])
 				+ m[2][0] * (m[0][1] * m[1][2] - m[1][1] * m[0][2]));
 
-			tmat3x3<T, P> Inverse(uninitialize);
+			mat<3, 3, T, P> Inverse(uninitialize);
 			Inverse[0][0] = + (m[1][1] * m[2][2] - m[2][1] * m[1][2]) * OneOverDeterminant;
 			Inverse[1][0] = - (m[1][0] * m[2][2] - m[2][0] * m[1][2]) * OneOverDeterminant;
 			Inverse[2][0] = + (m[1][0] * m[2][1] - m[2][0] * m[1][1]) * OneOverDeterminant;
@@ -293,10 +293,10 @@ namespace detail
 		}
 	};
 
-	template <typename T, precision P, bool Aligned>
-	struct compute_inverse<tmat4x4, T, P, Aligned>
+	template<typename T, precision P, bool Aligned>
+	struct compute_inverse<mat, 4, 4, T, P, Aligned>
 	{
-		GLM_FUNC_QUALIFIER static tmat4x4<T, P> call(tmat4x4<T, P> const& m)
+		GLM_FUNC_QUALIFIER static mat<4, 4, T, P> call(mat<4, 4, T, P> const& m)
 		{
 			T Coef00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
 			T Coef02 = m[1][2] * m[3][3] - m[3][2] * m[1][3];
@@ -322,30 +322,30 @@ namespace detail
 			T Coef22 = m[1][0] * m[3][1] - m[3][0] * m[1][1];
 			T Coef23 = m[1][0] * m[2][1] - m[2][0] * m[1][1];
 
-			tvec4<T, P> Fac0(Coef00, Coef00, Coef02, Coef03);
-			tvec4<T, P> Fac1(Coef04, Coef04, Coef06, Coef07);
-			tvec4<T, P> Fac2(Coef08, Coef08, Coef10, Coef11);
-			tvec4<T, P> Fac3(Coef12, Coef12, Coef14, Coef15);
-			tvec4<T, P> Fac4(Coef16, Coef16, Coef18, Coef19);
-			tvec4<T, P> Fac5(Coef20, Coef20, Coef22, Coef23);
+			vec<4, T, P> Fac0(Coef00, Coef00, Coef02, Coef03);
+			vec<4, T, P> Fac1(Coef04, Coef04, Coef06, Coef07);
+			vec<4, T, P> Fac2(Coef08, Coef08, Coef10, Coef11);
+			vec<4, T, P> Fac3(Coef12, Coef12, Coef14, Coef15);
+			vec<4, T, P> Fac4(Coef16, Coef16, Coef18, Coef19);
+			vec<4, T, P> Fac5(Coef20, Coef20, Coef22, Coef23);
 
-			tvec4<T, P> Vec0(m[1][0], m[0][0], m[0][0], m[0][0]);
-			tvec4<T, P> Vec1(m[1][1], m[0][1], m[0][1], m[0][1]);
-			tvec4<T, P> Vec2(m[1][2], m[0][2], m[0][2], m[0][2]);
-			tvec4<T, P> Vec3(m[1][3], m[0][3], m[0][3], m[0][3]);
+			vec<4, T, P> Vec0(m[1][0], m[0][0], m[0][0], m[0][0]);
+			vec<4, T, P> Vec1(m[1][1], m[0][1], m[0][1], m[0][1]);
+			vec<4, T, P> Vec2(m[1][2], m[0][2], m[0][2], m[0][2]);
+			vec<4, T, P> Vec3(m[1][3], m[0][3], m[0][3], m[0][3]);
 
-			tvec4<T, P> Inv0(Vec1 * Fac0 - Vec2 * Fac1 + Vec3 * Fac2);
-			tvec4<T, P> Inv1(Vec0 * Fac0 - Vec2 * Fac3 + Vec3 * Fac4);
-			tvec4<T, P> Inv2(Vec0 * Fac1 - Vec1 * Fac3 + Vec3 * Fac5);
-			tvec4<T, P> Inv3(Vec0 * Fac2 - Vec1 * Fac4 + Vec2 * Fac5);
+			vec<4, T, P> Inv0(Vec1 * Fac0 - Vec2 * Fac1 + Vec3 * Fac2);
+			vec<4, T, P> Inv1(Vec0 * Fac0 - Vec2 * Fac3 + Vec3 * Fac4);
+			vec<4, T, P> Inv2(Vec0 * Fac1 - Vec1 * Fac3 + Vec3 * Fac5);
+			vec<4, T, P> Inv3(Vec0 * Fac2 - Vec1 * Fac4 + Vec2 * Fac5);
 
-			tvec4<T, P> SignA(+1, -1, +1, -1);
-			tvec4<T, P> SignB(-1, +1, -1, +1);
-			tmat4x4<T, P> Inverse(Inv0 * SignA, Inv1 * SignB, Inv2 * SignA, Inv3 * SignB);
+			vec<4, T, P> SignA(+1, -1, +1, -1);
+			vec<4, T, P> SignB(-1, +1, -1, +1);
+			mat<4, 4, T, P> Inverse(Inv0 * SignA, Inv1 * SignB, Inv2 * SignA, Inv3 * SignB);
 
-			tvec4<T, P> Row0(Inverse[0][0], Inverse[1][0], Inverse[2][0], Inverse[3][0]);
+			vec<4, T, P> Row0(Inverse[0][0], Inverse[1][0], Inverse[2][0], Inverse[3][0]);
 
-			tvec4<T, P> Dot0(m[0] * Row0);
+			vec<4, T, P> Dot0(m[0] * Row0);
 			T Dot1 = (Dot0.x + Dot0.y) + (Dot0.z + Dot0.w);
 
 			T OneOverDeterminant = static_cast<T>(1) / Dot1;
@@ -355,43 +355,43 @@ namespace detail
 	};
 }//namespace detail
 
-	template <typename T, precision P, template <typename, precision> class matType>
-	GLM_FUNC_QUALIFIER matType<T, P> matrixCompMult(matType<T, P> const & x, matType<T, P> const & y)
+	template<length_t C, length_t R, typename T, precision P, template<length_t, length_t, typename, precision> class matType>
+	GLM_FUNC_QUALIFIER matType<C, R, T, P> matrixCompMult(matType<C, R, T, P> const & x, matType<C, R, T, P> const & y)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'matrixCompMult' only accept floating-point inputs");
-		return detail::compute_matrixCompMult<matType, T, P, detail::is_aligned<P>::value>::call(x, y);
+		return detail::compute_matrixCompMult<matType, C, R, T, P, detail::is_aligned<P>::value>::call(x, y);
 	}
 
-	template<typename T, precision P, template <typename, precision> class vecTypeA, template <typename, precision> class vecTypeB>
-	GLM_FUNC_QUALIFIER typename detail::outerProduct_trait<T, P, vecTypeA, vecTypeB>::type outerProduct(vecTypeA<T, P> const & c, vecTypeB<T, P> const & r)
+	template<int DA, int DB, typename T, precision P, template<length_t, typename, precision> class vecTypeA, template<length_t, typename, precision> class vecTypeB>
+	GLM_FUNC_QUALIFIER typename detail::outerProduct_trait<DA, DB, T, P, vecTypeA, vecTypeB>::type outerProduct(vecTypeA<DA, T, P> const & c, vecTypeB<DB, T, P> const & r)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'outerProduct' only accept floating-point inputs");
 
-		typename detail::outerProduct_trait<T, P, vecTypeA, vecTypeB>::type m(uninitialize);
+		typename detail::outerProduct_trait<DA, DB, T, P, vecTypeA, vecTypeB>::type m(uninitialize);
 		for(length_t i = 0; i < m.length(); ++i)
 			m[i] = c * r[i];
 		return m;
 	}
 
-	template <typename T, precision P, template <typename, precision> class matType>
-	GLM_FUNC_QUALIFIER typename matType<T, P>::transpose_type transpose(matType<T, P> const & m)
+	template<length_t C, length_t R, typename T, precision P, template<length_t, length_t, typename, precision> class matType>
+	GLM_FUNC_QUALIFIER typename matType<C, R, T, P>::transpose_type transpose(matType<C, R, T, P> const & m)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'transpose' only accept floating-point inputs");
-		return detail::compute_transpose<matType, T, P, detail::is_aligned<P>::value>::call(m);
+		return detail::compute_transpose<matType, C, R, T, P, detail::is_aligned<P>::value>::call(m);
 	}
 
-	template <typename T, precision P, template <typename, precision> class matType>
-	GLM_FUNC_QUALIFIER T determinant(matType<T, P> const & m)
+	template<length_t C, length_t R, typename T, precision P, template<length_t, length_t, typename, precision> class matType>
+	GLM_FUNC_QUALIFIER T determinant(matType<C, R, T, P> const & m)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'determinant' only accept floating-point inputs");
-		return detail::compute_determinant<matType, T, P, detail::is_aligned<P>::value>::call(m);
+		return detail::compute_determinant<matType, C, R, T, P, detail::is_aligned<P>::value>::call(m);
 	}
 
-	template <typename T, precision P, template <typename, precision> class matType>
-	GLM_FUNC_QUALIFIER matType<T, P> inverse(matType<T, P> const & m)
+	template<length_t C, length_t R, typename T, precision P, template<length_t, length_t, typename, precision> class matType>
+	GLM_FUNC_QUALIFIER matType<C, R, T, P> inverse(matType<C, R, T, P> const & m)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'inverse' only accept floating-point inputs");
-		return detail::compute_inverse<matType, T, P, detail::is_aligned<P>::value>::call(m);
+		return detail::compute_inverse<matType, C, R, T, P, detail::is_aligned<P>::value>::call(m);
 	}
 }//namespace glm
 
diff --git a/glm/detail/func_matrix_simd.inl b/glm/detail/func_matrix_simd.inl
index 61b0a5ba..99491866 100644
--- a/glm/detail/func_matrix_simd.inl
+++ b/glm/detail/func_matrix_simd.inl
@@ -10,14 +10,14 @@
 namespace glm{
 namespace detail
 {
-	template <precision P>
-	struct compute_matrixCompMult<tmat4x4, float, P, true>
+	template<precision P>
+	struct compute_matrixCompMult<mat, 4, 4, float, P, true>
 	{
 		GLM_STATIC_ASSERT(detail::is_aligned<P>::value, "Specialization requires aligned");
 
-		GLM_FUNC_QUALIFIER static tmat4x4<float, P> call(tmat4x4<float, P> const & x, tmat4x4<float, P> const & y)
+		GLM_FUNC_QUALIFIER static mat<4, 4, float, P> call(mat<4, 4, float, P> const & x, mat<4, 4, float, P> const & y)
 		{
-			tmat4x4<float, P> result(uninitialize);
+			mat<4, 4, float, P> result(uninitialize);
 			glm_mat4_matrixCompMult(
 				*(glm_vec4 const (*)[4])&x[0].data,
 				*(glm_vec4 const (*)[4])&y[0].data,
@@ -26,12 +26,12 @@ namespace detail
 		}
 	};
 
-	template <precision P>
-	struct compute_transpose<tmat4x4, float, P, true>
+	template<precision P>
+	struct compute_transpose<mat, 4, 4, float, P, true>
 	{
-		GLM_FUNC_QUALIFIER static tmat4x4<float, P> call(tmat4x4<float, P> const & m)
+		GLM_FUNC_QUALIFIER static mat<4, 4, float, P> call(mat<4, 4, float, P> const & m)
 		{
-			tmat4x4<float, P> result(uninitialize);
+			mat<4, 4, float, P> result(uninitialize);
 			glm_mat4_transpose(
 				*(glm_vec4 const (*)[4])&m[0].data,
 				*(glm_vec4(*)[4])&result[0].data);
@@ -39,21 +39,21 @@ namespace detail
 		}
 	};
 
-	template <precision P>
-	struct compute_determinant<tmat4x4, float, P, true>
+	template<precision P>
+	struct compute_determinant<mat, 4, 4, float, P, true>
 	{
-		GLM_FUNC_QUALIFIER static float call(tmat4x4<float, P> const& m)
+		GLM_FUNC_QUALIFIER static float call(mat<4, 4, float, P> const& m)
 		{
 			return _mm_cvtss_f32(glm_mat4_determinant(*reinterpret_cast<__m128 const(*)[4]>(&m[0].data)));
 		}
 	};
 
-	template <precision P>
-	struct compute_inverse<tmat4x4, float, P, true>
+	template<precision P>
+	struct compute_inverse<mat, 4, 4, float, P, true>
 	{
-		GLM_FUNC_QUALIFIER static tmat4x4<float, P> call(tmat4x4<float, P> const& m)
+		GLM_FUNC_QUALIFIER static mat<4, 4, float, P> call(mat<4, 4, float, P> const& m)
 		{
-			tmat4x4<float, P> Result(uninitialize);
+			mat<4, 4, float, P> Result(uninitialize);
 			glm_mat4_inverse(*reinterpret_cast<__m128 const(*)[4]>(&m[0].data), *reinterpret_cast<__m128(*)[4]>(&Result[0].data));
 			return Result;
 		}
@@ -61,25 +61,25 @@ namespace detail
 }//namespace detail
 
 	template<>
-	GLM_FUNC_QUALIFIER tmat4x4<float, aligned_lowp> outerProduct<float, aligned_lowp, tvec4, tvec4>(tvec4<float, aligned_lowp> const & c, tvec4<float, aligned_lowp> const & r)
+	GLM_FUNC_QUALIFIER mat<4, 4, float, aligned_lowp> outerProduct<4, 4, float, aligned_lowp, vec, vec>(vec<4, float, aligned_lowp> const & c, vec<4, float, aligned_lowp> const & r)
 	{
-		tmat4x4<float, aligned_lowp> m(uninitialize);
+		mat<4, 4, float, aligned_lowp> m(uninitialize);
 		glm_mat4_outerProduct(c.data, r.data, *reinterpret_cast<__m128(*)[4]>(&m[0].data));
 		return m;
 	}
 
 	template<>
-	GLM_FUNC_QUALIFIER tmat4x4<float, aligned_mediump> outerProduct<float, aligned_mediump, tvec4, tvec4>(tvec4<float, aligned_mediump> const & c, tvec4<float, aligned_mediump> const & r)
+	GLM_FUNC_QUALIFIER mat<4, 4, float, aligned_mediump> outerProduct<4, 4, float, aligned_mediump, vec, vec>(vec<4, float, aligned_mediump> const & c, vec<4, float, aligned_mediump> const & r)
 	{
-		tmat4x4<float, aligned_mediump> m(uninitialize);
+		mat<4, 4, float, aligned_mediump> m(uninitialize);
 		glm_mat4_outerProduct(c.data, r.data, *reinterpret_cast<__m128(*)[4]>(&m[0].data));
 		return m;
 	}
 
 	template<>
-	GLM_FUNC_QUALIFIER tmat4x4<float, aligned_highp> outerProduct<float, aligned_highp, tvec4, tvec4>(tvec4<float, aligned_highp> const & c, tvec4<float, aligned_highp> const & r)
+	GLM_FUNC_QUALIFIER mat<4, 4, float, aligned_highp> outerProduct<4, 4, float, aligned_highp, vec, vec>(vec<4, float, aligned_highp> const & c, vec<4, float, aligned_highp> const & r)
 	{
-		tmat4x4<float, aligned_highp> m(uninitialize);
+		mat<4, 4, float, aligned_highp> m(uninitialize);
 		glm_mat4_outerProduct(c.data, r.data, *reinterpret_cast<__m128(*)[4]>(&m[0].data));
 		return m;
 	}
diff --git a/glm/detail/func_trigonometric.hpp b/glm/detail/func_trigonometric.hpp
index 719cff0b..f17ba6d1 100644
--- a/glm/detail/func_trigonometric.hpp
+++ b/glm/detail/func_trigonometric.hpp
@@ -28,8 +28,8 @@ namespace glm
 	///
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/radians.xml">GLSL radians man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL GLM_CONSTEXPR vecType<T, P> radians(vecType<T, P> const & degrees);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL GLM_CONSTEXPR vecType<L, T, P> radians(vecType<L, T, P> const & degrees);
 
 	/// Converts radians to degrees and returns the result.
 	///
@@ -37,8 +37,8 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/degrees.xml">GLSL degrees man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL GLM_CONSTEXPR vecType<T, P> degrees(vecType<T, P> const & radians);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL GLM_CONSTEXPR vecType<L, T, P> degrees(vecType<L, T, P> const & radians);
 
 	/// The standard trigonometric sine function. 
 	/// The values returned by this function will range from [-1, 1].
@@ -47,8 +47,8 @@ namespace glm
 	///
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/sin.xml">GLSL sin man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> sin(vecType<T, P> const & angle);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, T, P> sin(vecType<L, T, P> const & angle);
 
 	/// The standard trigonometric cosine function. 
 	/// The values returned by this function will range from [-1, 1].
@@ -57,8 +57,8 @@ namespace glm
 	///
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/cos.xml">GLSL cos man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> cos(vecType<T, P> const & angle);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, T, P> cos(vecType<L, T, P> const & angle);
 
 	/// The standard trigonometric tangent function.
 	///
@@ -66,8 +66,8 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/tan.xml">GLSL tan man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> tan(vecType<T, P> const & angle); 
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, T, P> tan(vecType<L, T, P> const & angle);
 
 	/// Arc sine. Returns an angle whose sine is x. 
 	/// The range of values returned by this function is [-PI/2, PI/2]. 
@@ -77,8 +77,8 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/asin.xml">GLSL asin man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> asin(vecType<T, P> const & x);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, T, P> asin(vecType<L, T, P> const & x);
 
 	/// Arc cosine. Returns an angle whose sine is x. 
 	/// The range of values returned by this function is [0, PI]. 
@@ -88,8 +88,8 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/acos.xml">GLSL acos man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> acos(vecType<T, P> const & x);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, T, P> acos(vecType<L, T, P> const & x);
 
 	/// Arc tangent. Returns an angle whose tangent is y/x. 
 	/// The signs of x and y are used to determine what 
@@ -101,8 +101,8 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/atan.xml">GLSL atan man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> atan(vecType<T, P> const & y, vecType<T, P> const & x);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, T, P> atan(vecType<L, T, P> const & y, vecType<L, T, P> const & x);
 
 	/// Arc tangent. Returns an angle whose tangent is y_over_x. 
 	/// The range of values returned by this function is [-PI/2, PI/2].
@@ -111,8 +111,8 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/atan.xml">GLSL atan man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> atan(vecType<T, P> const & y_over_x);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, T, P> atan(vecType<L, T, P> const & y_over_x);
 
 	/// Returns the hyperbolic sine function, (exp(x) - exp(-x)) / 2
 	///
@@ -120,8 +120,8 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/sinh.xml">GLSL sinh man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> sinh(vecType<T, P> const & angle);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, T, P> sinh(vecType<L, T, P> const & angle);
 
 	/// Returns the hyperbolic cosine function, (exp(x) + exp(-x)) / 2
 	///
@@ -129,8 +129,8 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/cosh.xml">GLSL cosh man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> cosh(vecType<T, P> const & angle);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, T, P> cosh(vecType<L, T, P> const & angle);
 
 	/// Returns the hyperbolic tangent function, sinh(angle) / cosh(angle)
 	///
@@ -138,8 +138,8 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/tanh.xml">GLSL tanh man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> tanh(vecType<T, P> const & angle);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, T, P> tanh(vecType<L, T, P> const & angle);
 
 	/// Arc hyperbolic sine; returns the inverse of sinh.
 	///
@@ -147,8 +147,8 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/asinh.xml">GLSL asinh man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> asinh(vecType<T, P> const & x);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, T, P> asinh(vecType<L, T, P> const & x);
 	
 	/// Arc hyperbolic cosine; returns the non-negative inverse
 	/// of cosh. Results are undefined if x < 1.
@@ -157,8 +157,8 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/acosh.xml">GLSL acosh man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> acosh(vecType<T, P> const & x);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, T, P> acosh(vecType<L, T, P> const & x);
 
 	/// Arc hyperbolic tangent; returns the inverse of tanh.
 	/// Results are undefined if abs(x) >= 1.
@@ -167,8 +167,8 @@ namespace glm
 	///
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/atanh.xml">GLSL atanh man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> atanh(vecType<T, P> const & x);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, T, P> atanh(vecType<L, T, P> const & x);
 
 	/// @}
 }//namespace glm
diff --git a/glm/detail/func_trigonometric.inl b/glm/detail/func_trigonometric.inl
index 29866734..952273dc 100644
--- a/glm/detail/func_trigonometric.inl
+++ b/glm/detail/func_trigonometric.inl
@@ -8,7 +8,7 @@
 namespace glm
 {
 	// radians
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType radians(genType degrees)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'radians' only accept floating-point input");
@@ -16,14 +16,14 @@ namespace glm
 		return degrees * static_cast<genType>(0.01745329251994329576923690768489);
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vecType<T, P> radians(vecType<T, P> const & v)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vecType<L, T, P> radians(vecType<L, T, P> const & v)
 	{
-		return detail::functor1<T, T, P, vecType>::call(radians, v);
+		return detail::functor1<L, T, T, P>::call(radians, v);
 	}
 	
 	// degrees
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType degrees(genType radians)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'degrees' only accept floating-point input");
@@ -31,59 +31,59 @@ namespace glm
 		return radians * static_cast<genType>(57.295779513082320876798154814105);
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vecType<T, P> degrees(vecType<T, P> const & v)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vecType<L, T, P> degrees(vecType<L, T, P> const & v)
 	{
-		return detail::functor1<T, T, P, vecType>::call(degrees, v);
+		return detail::functor1<L, T, T, P>::call(degrees, v);
 	}
 
 	// sin
 	using ::std::sin;
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> sin(vecType<T, P> const & v)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> sin(vecType<L, T, P> const & v)
 	{
-		return detail::functor1<T, T, P, vecType>::call(sin, v);
+		return detail::functor1<L, T, T, P>::call(sin, v);
 	}
 
 	// cos
 	using std::cos;
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> cos(vecType<T, P> const & v)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> cos(vecType<L, T, P> const & v)
 	{
-		return detail::functor1<T, T, P, vecType>::call(cos, v);
+		return detail::functor1<L, T, T, P>::call(cos, v);
 	}
 
 	// tan
 	using std::tan;
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> tan(vecType<T, P> const & v)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> tan(vecType<L, T, P> const & v)
 	{
-		return detail::functor1<T, T, P, vecType>::call(tan, v);
+		return detail::functor1<L, T, T, P>::call(tan, v);
 	}
 
 	// asin
 	using std::asin;
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> asin(vecType<T, P> const & v)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> asin(vecType<L, T, P> const & v)
 	{
-		return detail::functor1<T, T, P, vecType>::call(asin, v);
+		return detail::functor1<L, T, T, P>::call(asin, v);
 	}
 
 	// acos
 	using std::acos;
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> acos(vecType<T, P> const & v)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> acos(vecType<L, T, P> const & v)
 	{
-		return detail::functor1<T, T, P, vecType>::call(acos, v);
+		return detail::functor1<L, T, T, P>::call(acos, v);
 	}
 
 	// atan
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER genType atan(genType y, genType x)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'atan' only accept floating-point input");
@@ -91,52 +91,52 @@ namespace glm
 		return ::std::atan2(y, x);
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> atan(vecType<T, P> const & a, vecType<T, P> const & b)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> atan(vecType<L, T, P> const & a, vecType<L, T, P> const & b)
 	{
-		return detail::functor2<T, P, vecType>::call(::std::atan2, a, b);
+		return detail::functor2<L, T, P>::call(::std::atan2, a, b);
 	}
 
 	using std::atan;
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> atan(vecType<T, P> const & v)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> atan(vecType<L, T, P> const & v)
 	{
-		return detail::functor1<T, T, P, vecType>::call(atan, v);
+		return detail::functor1<L, T, T, P>::call(atan, v);
 	}
 
 	// sinh
 	using std::sinh;
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> sinh(vecType<T, P> const & v)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> sinh(vecType<L, T, P> const & v)
 	{
-		return detail::functor1<T, T, P, vecType>::call(sinh, v);
+		return detail::functor1<L, T, T, P>::call(sinh, v);
 	}
 
 	// cosh
 	using std::cosh;
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> cosh(vecType<T, P> const & v)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> cosh(vecType<L, T, P> const & v)
 	{
-		return detail::functor1<T, T, P, vecType>::call(cosh, v);
+		return detail::functor1<L, T, T, P>::call(cosh, v);
 	}
 
 	// tanh
 	using std::tanh;
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> tanh(vecType<T, P> const & v)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> tanh(vecType<L, T, P> const & v)
 	{
-		return detail::functor1<T, T, P, vecType>::call(tanh, v);
+		return detail::functor1<L, T, T, P>::call(tanh, v);
 	}
 
 	// asinh
 #	if GLM_HAS_CXX11_STL
 		using std::asinh;
 #	else
-		template <typename genType>
+		template<typename genType>
 		GLM_FUNC_QUALIFIER genType asinh(genType x)
 		{
 			GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'asinh' only accept floating-point input");
@@ -145,17 +145,17 @@ namespace glm
 		}
 #	endif
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> asinh(vecType<T, P> const & v)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> asinh(vecType<L, T, P> const & v)
 	{
-		return detail::functor1<T, T, P, vecType>::call(asinh, v);
+		return detail::functor1<L, T, T, P>::call(asinh, v);
 	}
 
 	// acosh
 #	if GLM_HAS_CXX11_STL
 		using std::acosh;
 #	else
-		template <typename genType> 
+		template<typename genType> 
 		GLM_FUNC_QUALIFIER genType acosh(genType x)
 		{
 			GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'acosh' only accept floating-point input");
@@ -166,17 +166,17 @@ namespace glm
 		}
 #	endif
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> acosh(vecType<T, P> const & v)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> acosh(vecType<L, T, P> const & v)
 	{
-		return detail::functor1<T, T, P, vecType>::call(acosh, v);
+		return detail::functor1<L, T, T, P>::call(acosh, v);
 	}
 
 	// atanh
 #	if GLM_HAS_CXX11_STL
 		using std::atanh;
 #	else
-		template <typename genType>
+		template<typename genType>
 		GLM_FUNC_QUALIFIER genType atanh(genType x)
 		{
 			GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'atanh' only accept floating-point input");
@@ -187,10 +187,10 @@ namespace glm
 		}
 #	endif
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> atanh(vecType<T, P> const & v)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> atanh(vecType<L, T, P> const & v)
 	{
-		return detail::functor1<T, T, P, vecType>::call(atanh, v);
+		return detail::functor1<L, T, T, P>::call(atanh, v);
 	}
 }//namespace glm
 
diff --git a/glm/detail/func_vector_relational.hpp b/glm/detail/func_vector_relational.hpp
index ec0f68a7..f981bd7f 100644
--- a/glm/detail/func_vector_relational.hpp
+++ b/glm/detail/func_vector_relational.hpp
@@ -29,8 +29,8 @@ namespace glm
 	///
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/lessThan.xml">GLSL lessThan man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<bool, P> lessThan(vecType<T, P> const & x, vecType<T, P> const & y);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, bool, P> lessThan(vecType<L, T, P> const & x, vecType<L, T, P> const & y);
 
 	/// Returns the component-wise comparison of result x <= y.
 	///
@@ -38,8 +38,8 @@ namespace glm
 	///
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/lessThanEqual.xml">GLSL lessThanEqual man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<bool, P> lessThanEqual(vecType<T, P> const & x, vecType<T, P> const & y);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, bool, P> lessThanEqual(vecType<L, T, P> const & x, vecType<L, T, P> const & y);
 
 	/// Returns the component-wise comparison of result x > y.
 	///
@@ -47,8 +47,8 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/greaterThan.xml">GLSL greaterThan man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<bool, P> greaterThan(vecType<T, P> const & x, vecType<T, P> const & y);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, bool, P> greaterThan(vecType<L, T, P> const & x, vecType<L, T, P> const & y);
 
 	/// Returns the component-wise comparison of result x >= y.
 	///
@@ -56,8 +56,8 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/greaterThanEqual.xml">GLSL greaterThanEqual man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<bool, P> greaterThanEqual(vecType<T, P> const & x, vecType<T, P> const & y);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, bool, P> greaterThanEqual(vecType<L, T, P> const & x, vecType<L, T, P> const & y);
 
 	/// Returns the component-wise comparison of result x == y.
 	///
@@ -65,8 +65,8 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/equal.xml">GLSL equal man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<bool, P> equal(vecType<T, P> const & x, vecType<T, P> const & y);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, bool, P> equal(vecType<L, T, P> const & x, vecType<L, T, P> const & y);
 
 	/// Returns the component-wise comparison of result x != y.
 	/// 
@@ -74,8 +74,8 @@ namespace glm
 	///
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/notEqual.xml">GLSL notEqual man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<bool, P> notEqual(vecType<T, P> const & x, vecType<T, P> const & y);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, bool, P> notEqual(vecType<L, T, P> const & x, vecType<L, T, P> const & y);
 
 	/// Returns true if any component of x is true.
 	///
@@ -83,8 +83,8 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/any.xml">GLSL any man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
-	template <precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL bool any(vecType<bool, P> const & v);
+	template<length_t L, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL bool any(vecType<L, bool, P> const & v);
 
 	/// Returns true if all components of x are true.
 	///
@@ -92,8 +92,8 @@ namespace glm
 	///
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/all.xml">GLSL all man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
-	template <precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL bool all(vecType<bool, P> const & v);
+	template<length_t L, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL bool all(vecType<L, bool, P> const & v);
 
 	/// Returns the component-wise logical complement of x.
 	/// /!\ Because of language incompatibilities between C++ and GLSL, GLM defines the function not but not_ instead.
@@ -102,8 +102,8 @@ namespace glm
 	///
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/not.xml">GLSL not man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
-	template <precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<bool, P> not_(vecType<bool, P> const & v);
+	template<length_t L, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, bool, P> not_(vecType<L, bool, P> const & v);
 
 	/// @}
 }//namespace glm
diff --git a/glm/detail/func_vector_relational.inl b/glm/detail/func_vector_relational.inl
index 3d8d2b7e..88ab56da 100644
--- a/glm/detail/func_vector_relational.inl
+++ b/glm/detail/func_vector_relational.inl
@@ -5,75 +5,75 @@
 
 namespace glm
 {
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<bool, P> lessThan(vecType<T, P> const & x, vecType<T, P> const & y)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, bool, P> lessThan(vecType<L, T, P> const & x, vecType<L, T, P> const & y)
 	{
 		assert(x.length() == y.length());
 
-		vecType<bool, P> Result(uninitialize);
+		vecType<L, bool, P> Result(uninitialize);
 		for(length_t i = 0; i < x.length(); ++i)
 			Result[i] = x[i] < y[i];
 
 		return Result;
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<bool, P> lessThanEqual(vecType<T, P> const & x, vecType<T, P> const & y)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, bool, P> lessThanEqual(vecType<L, T, P> const & x, vecType<L, T, P> const & y)
 	{
 		assert(x.length() == y.length());
 
-		vecType<bool, P> Result(uninitialize);
+		vecType<L, bool, P> Result(uninitialize);
 		for(length_t i = 0; i < x.length(); ++i)
 			Result[i] = x[i] <= y[i];
 		return Result;
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<bool, P> greaterThan(vecType<T, P> const & x, vecType<T, P> const & y)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, bool, P> greaterThan(vecType<L, T, P> const & x, vecType<L, T, P> const & y)
 	{
 		assert(x.length() == y.length());
 
-		vecType<bool, P> Result(uninitialize);
+		vecType<L, bool, P> Result(uninitialize);
 		for(length_t i = 0; i < x.length(); ++i)
 			Result[i] = x[i] > y[i];
 		return Result;
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<bool, P> greaterThanEqual(vecType<T, P> const & x, vecType<T, P> const & y)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, bool, P> greaterThanEqual(vecType<L, T, P> const & x, vecType<L, T, P> const & y)
 	{
 		assert(x.length() == y.length());
 
-		vecType<bool, P> Result(uninitialize);
+		vecType<L, bool, P> Result(uninitialize);
 		for(length_t i = 0; i < x.length(); ++i)
 			Result[i] = x[i] >= y[i];
 		return Result;
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<bool, P> equal(vecType<T, P> const & x, vecType<T, P> const & y)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, bool, P> equal(vecType<L, T, P> const & x, vecType<L, T, P> const & y)
 	{
 		assert(x.length() == y.length());
 
-		vecType<bool, P> Result(uninitialize);
+		vecType<L, bool, P> Result(uninitialize);
 		for(length_t i = 0; i < x.length(); ++i)
 			Result[i] = x[i] == y[i];
 		return Result;
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<bool, P> notEqual(vecType<T, P> const & x, vecType<T, P> const & y)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, bool, P> notEqual(vecType<L, T, P> const & x, vecType<L, T, P> const & y)
 	{
 		assert(x.length() == y.length());
 
-		vecType<bool, P> Result(uninitialize);
+		vecType<L, bool, P> Result(uninitialize);
 		for(length_t i = 0; i < x.length(); ++i)
 			Result[i] = x[i] != y[i];
 		return Result;
 	}
 
-	template <precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER bool any(vecType<bool, P> const & v)
+	template<length_t L, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER bool any(vecType<L, bool, P> const & v)
 	{
 		bool Result = false;
 		for(length_t i = 0; i < v.length(); ++i)
@@ -81,8 +81,8 @@ namespace glm
 		return Result;
 	}
 
-	template <precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER bool all(vecType<bool, P> const & v)
+	template<length_t L, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER bool all(vecType<L, bool, P> const & v)
 	{
 		bool Result = true;
 		for(length_t i = 0; i < v.length(); ++i)
@@ -90,10 +90,10 @@ namespace glm
 		return Result;
 	}
 
-	template <precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<bool, P> not_(vecType<bool, P> const & v)
+	template<length_t L, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, bool, P> not_(vecType<L, bool, P> const & v)
 	{
-		vecType<bool, P> Result(uninitialize);
+		vecType<L, bool, P> Result(uninitialize);
 		for(length_t i = 0; i < v.length(); ++i)
 			Result[i] = !v[i];
 		return Result;
diff --git a/glm/detail/glm.cpp b/glm/detail/glm.cpp
index 0fc085e5..9cbdd029 100644
--- a/glm/detail/glm.cpp
+++ b/glm/detail/glm.cpp
@@ -9,230 +9,230 @@
 namespace glm
 {
 // tvec1 type explicit instantiation
-template struct tvec1<uint8, lowp>;
-template struct tvec1<uint16, lowp>;
-template struct tvec1<uint32, lowp>;
-template struct tvec1<uint64, lowp>;
-template struct tvec1<int8, lowp>;
-template struct tvec1<int16, lowp>;
-template struct tvec1<int32, lowp>;
-template struct tvec1<int64, lowp>;
-template struct tvec1<float32, lowp>;
-template struct tvec1<float64, lowp>;
+template struct vec<1, uint8, lowp>;
+template struct vec<1, uint16, lowp>;
+template struct vec<1, uint32, lowp>;
+template struct vec<1, uint64, lowp>;
+template struct vec<1, int8, lowp>;
+template struct vec<1, int16, lowp>;
+template struct vec<1, int32, lowp>;
+template struct vec<1, int64, lowp>;
+template struct vec<1, float32, lowp>;
+template struct vec<1, float64, lowp>;
 
-template struct tvec1<uint8, mediump>;
-template struct tvec1<uint16, mediump>;
-template struct tvec1<uint32, mediump>;
-template struct tvec1<uint64, mediump>;
-template struct tvec1<int8, mediump>;
-template struct tvec1<int16, mediump>;
-template struct tvec1<int32, mediump>;
-template struct tvec1<int64, mediump>;
-template struct tvec1<float32, mediump>;
-template struct tvec1<float64, mediump>;
+template struct vec<1, uint8, mediump>;
+template struct vec<1, uint16, mediump>;
+template struct vec<1, uint32, mediump>;
+template struct vec<1, uint64, mediump>;
+template struct vec<1, int8, mediump>;
+template struct vec<1, int16, mediump>;
+template struct vec<1, int32, mediump>;
+template struct vec<1, int64, mediump>;
+template struct vec<1, float32, mediump>;
+template struct vec<1, float64, mediump>;
 
-template struct tvec1<uint8, highp>;
-template struct tvec1<uint16, highp>;
-template struct tvec1<uint32, highp>;
-template struct tvec1<uint64, highp>;
-template struct tvec1<int8, highp>;
-template struct tvec1<int16, highp>;
-template struct tvec1<int32, highp>;
-template struct tvec1<int64, highp>;
-template struct tvec1<float32, highp>;
-template struct tvec1<float64, highp>;
+template struct vec<1, uint8, highp>;
+template struct vec<1, uint16, highp>;
+template struct vec<1, uint32, highp>;
+template struct vec<1, uint64, highp>;
+template struct vec<1, int8, highp>;
+template struct vec<1, int16, highp>;
+template struct vec<1, int32, highp>;
+template struct vec<1, int64, highp>;
+template struct vec<1, float32, highp>;
+template struct vec<1, float64, highp>;
 
 // tvec2 type explicit instantiation
-template struct tvec2<uint8, lowp>;
-template struct tvec2<uint16, lowp>;
-template struct tvec2<uint32, lowp>;
-template struct tvec2<uint64, lowp>;
-template struct tvec2<int8, lowp>;
-template struct tvec2<int16, lowp>;
-template struct tvec2<int32, lowp>;
-template struct tvec2<int64, lowp>;
-template struct tvec2<float32, lowp>;
-template struct tvec2<float64, lowp>;
+template struct vec<2, uint8, lowp>;
+template struct vec<2, uint16, lowp>;
+template struct vec<2, uint32, lowp>;
+template struct vec<2, uint64, lowp>;
+template struct vec<2, int8, lowp>;
+template struct vec<2, int16, lowp>;
+template struct vec<2, int32, lowp>;
+template struct vec<2, int64, lowp>;
+template struct vec<2, float32, lowp>;
+template struct vec<2, float64, lowp>;
 
-template struct tvec2<uint8, mediump>;
-template struct tvec2<uint16, mediump>;
-template struct tvec2<uint32, mediump>;
-template struct tvec2<uint64, mediump>;
-template struct tvec2<int8, mediump>;
-template struct tvec2<int16, mediump>;
-template struct tvec2<int32, mediump>;
-template struct tvec2<int64, mediump>;
-template struct tvec2<float32, mediump>;
-template struct tvec2<float64, mediump>;
+template struct vec<2, uint8, mediump>;
+template struct vec<2, uint16, mediump>;
+template struct vec<2, uint32, mediump>;
+template struct vec<2, uint64, mediump>;
+template struct vec<2, int8, mediump>;
+template struct vec<2, int16, mediump>;
+template struct vec<2, int32, mediump>;
+template struct vec<2, int64, mediump>;
+template struct vec<2, float32, mediump>;
+template struct vec<2, float64, mediump>;
 
-template struct tvec2<uint8, highp>;
-template struct tvec2<uint16, highp>;
-template struct tvec2<uint32, highp>;
-template struct tvec2<uint64, highp>;
-template struct tvec2<int8, highp>;
-template struct tvec2<int16, highp>;
-template struct tvec2<int32, highp>;
-template struct tvec2<int64, highp>;
-template struct tvec2<float32, highp>;
-template struct tvec2<float64, highp>;
+template struct vec<2, uint8, highp>;
+template struct vec<2, uint16, highp>;
+template struct vec<2, uint32, highp>;
+template struct vec<2, uint64, highp>;
+template struct vec<2, int8, highp>;
+template struct vec<2, int16, highp>;
+template struct vec<2, int32, highp>;
+template struct vec<2, int64, highp>;
+template struct vec<2, float32, highp>;
+template struct vec<2, float64, highp>;
 
 // tvec3 type explicit instantiation
-template struct tvec3<uint8, lowp>;
-template struct tvec3<uint16, lowp>;
-template struct tvec3<uint32, lowp>;
-template struct tvec3<uint64, lowp>;
-template struct tvec3<int8, lowp>;
-template struct tvec3<int16, lowp>;
-template struct tvec3<int32, lowp>;
-template struct tvec3<int64, lowp>;
-template struct tvec3<float32, lowp>;
-template struct tvec3<float64, lowp>;
+template struct vec<3, uint8, lowp>;
+template struct vec<3, uint16, lowp>;
+template struct vec<3, uint32, lowp>;
+template struct vec<3, uint64, lowp>;
+template struct vec<3, int8, lowp>;
+template struct vec<3, int16, lowp>;
+template struct vec<3, int32, lowp>;
+template struct vec<3, int64, lowp>;
+template struct vec<3, float32, lowp>;
+template struct vec<3, float64, lowp>;
 
-template struct tvec3<uint8, mediump>;
-template struct tvec3<uint16, mediump>;
-template struct tvec3<uint32, mediump>;
-template struct tvec3<uint64, mediump>;
-template struct tvec3<int8, mediump>;
-template struct tvec3<int16, mediump>;
-template struct tvec3<int32, mediump>;
-template struct tvec3<int64, mediump>;
-template struct tvec3<float32, mediump>;
-template struct tvec3<float64, mediump>;
+template struct vec<3, uint8, mediump>;
+template struct vec<3, uint16, mediump>;
+template struct vec<3, uint32, mediump>;
+template struct vec<3, uint64, mediump>;
+template struct vec<3, int8, mediump>;
+template struct vec<3, int16, mediump>;
+template struct vec<3, int32, mediump>;
+template struct vec<3, int64, mediump>;
+template struct vec<3, float32, mediump>;
+template struct vec<3, float64, mediump>;
 
-template struct tvec3<uint8, highp>;
-template struct tvec3<uint16, highp>;
-template struct tvec3<uint32, highp>;
-template struct tvec3<uint64, highp>;
-template struct tvec3<int8, highp>;
-template struct tvec3<int16, highp>;
-template struct tvec3<int32, highp>;
-template struct tvec3<int64, highp>;
-template struct tvec3<float32, highp>;
-template struct tvec3<float64, highp>;
+template struct vec<3, uint8, highp>;
+template struct vec<3, uint16, highp>;
+template struct vec<3, uint32, highp>;
+template struct vec<3, uint64, highp>;
+template struct vec<3, int8, highp>;
+template struct vec<3, int16, highp>;
+template struct vec<3, int32, highp>;
+template struct vec<3, int64, highp>;
+template struct vec<3, float32, highp>;
+template struct vec<3, float64, highp>;
 
 // tvec4 type explicit instantiation
-template struct tvec4<uint8, lowp>;
-template struct tvec4<uint16, lowp>;
-template struct tvec4<uint32, lowp>;
-template struct tvec4<uint64, lowp>;
-template struct tvec4<int8, lowp>;
-template struct tvec4<int16, lowp>;
-template struct tvec4<int32, lowp>;
-template struct tvec4<int64, lowp>;
-template struct tvec4<float32, lowp>;
-template struct tvec4<float64, lowp>;
+template struct vec<4, uint8, lowp>;
+template struct vec<4, uint16, lowp>;
+template struct vec<4, uint32, lowp>;
+template struct vec<4, uint64, lowp>;
+template struct vec<4, int8, lowp>;
+template struct vec<4, int16, lowp>;
+template struct vec<4, int32, lowp>;
+template struct vec<4, int64, lowp>;
+template struct vec<4, float32, lowp>;
+template struct vec<4, float64, lowp>;
 
-template struct tvec4<uint8, mediump>;
-template struct tvec4<uint16, mediump>;
-template struct tvec4<uint32, mediump>;
-template struct tvec4<uint64, mediump>;
-template struct tvec4<int8, mediump>;
-template struct tvec4<int16, mediump>;
-template struct tvec4<int32, mediump>;
-template struct tvec4<int64, mediump>;
-template struct tvec4<float32, mediump>;
-template struct tvec4<float64, mediump>;
+template struct vec<4, uint8, mediump>;
+template struct vec<4, uint16, mediump>;
+template struct vec<4, uint32, mediump>;
+template struct vec<4, uint64, mediump>;
+template struct vec<4, int8, mediump>;
+template struct vec<4, int16, mediump>;
+template struct vec<4, int32, mediump>;
+template struct vec<4, int64, mediump>;
+template struct vec<4, float32, mediump>;
+template struct vec<4, float64, mediump>;
 
-template struct tvec4<uint8, highp>;
-template struct tvec4<uint16, highp>;
-template struct tvec4<uint32, highp>;
-template struct tvec4<uint64, highp>;
-template struct tvec4<int8, highp>;
-template struct tvec4<int16, highp>;
-template struct tvec4<int32, highp>;
-template struct tvec4<int64, highp>;
-template struct tvec4<float32, highp>;
-template struct tvec4<float64, highp>;
+template struct vec<4, uint8, highp>;
+template struct vec<4, uint16, highp>;
+template struct vec<4, uint32, highp>;
+template struct vec<4, uint64, highp>;
+template struct vec<4, int8, highp>;
+template struct vec<4, int16, highp>;
+template struct vec<4, int32, highp>;
+template struct vec<4, int64, highp>;
+template struct vec<4, float32, highp>;
+template struct vec<4, float64, highp>;
 
 // tmat2x2 type explicit instantiation
-template struct tmat2x2<float32, lowp>;
-template struct tmat2x2<float64, lowp>;
+template struct mat<2, 2, float32, lowp>;
+template struct mat<2, 2, float64, lowp>;
 
-template struct tmat2x2<float32, mediump>;
-template struct tmat2x2<float64, mediump>;
+template struct mat<2, 2, float32, mediump>;
+template struct mat<2, 2, float64, mediump>;
 
-template struct tmat2x2<float32, highp>;
-template struct tmat2x2<float64, highp>;
+template struct mat<2, 2, float32, highp>;
+template struct mat<2, 2, float64, highp>;
 
 // tmat2x3 type explicit instantiation
-template struct tmat2x3<float32, lowp>;
-template struct tmat2x3<float64, lowp>;
+template struct mat<2, 3, float32, lowp>;
+template struct mat<2, 3, float64, lowp>;
 
-template struct tmat2x3<float32, mediump>;
-template struct tmat2x3<float64, mediump>;
+template struct mat<2, 3, float32, mediump>;
+template struct mat<2, 3, float64, mediump>;
 
-template struct tmat2x3<float32, highp>;
-template struct tmat2x3<float64, highp>;
+template struct mat<2, 3, float32, highp>;
+template struct mat<2, 3, float64, highp>;
 
 // tmat2x4 type explicit instantiation
-template struct tmat2x4<float32, lowp>;
-template struct tmat2x4<float64, lowp>;
+template struct mat<2, 4, float32, lowp>;
+template struct mat<2, 4, float64, lowp>;
 
-template struct tmat2x4<float32, mediump>;
-template struct tmat2x4<float64, mediump>;
+template struct mat<2, 4, float32, mediump>;
+template struct mat<2, 4, float64, mediump>;
 
-template struct tmat2x4<float32, highp>;
-template struct tmat2x4<float64, highp>;
+template struct mat<2, 4, float32, highp>;
+template struct mat<2, 4, float64, highp>;
 
 // tmat3x2 type explicit instantiation
-template struct tmat3x2<float32, lowp>;
-template struct tmat3x2<float64, lowp>;
+template struct mat<3, 2, float32, lowp>;
+template struct mat<3, 2, float64, lowp>;
 
-template struct tmat3x2<float32, mediump>;
-template struct tmat3x2<float64, mediump>;
+template struct mat<3, 2, float32, mediump>;
+template struct mat<3, 2, float64, mediump>;
 
-template struct tmat3x2<float32, highp>;
-template struct tmat3x2<float64, highp>;
+template struct mat<3, 2, float32, highp>;
+template struct mat<3, 2, float64, highp>;
 
 // tmat3x3 type explicit instantiation
-template struct tmat3x3<float32, lowp>;
-template struct tmat3x3<float64, lowp>;
+template struct mat<3, 3, float32, lowp>;
+template struct mat<3, 3, float64, lowp>;
 
-template struct tmat3x3<float32, mediump>;
-template struct tmat3x3<float64, mediump>;
+template struct mat<3, 3, float32, mediump>;
+template struct mat<3, 3, float64, mediump>;
 
-template struct tmat3x3<float32, highp>;
-template struct tmat3x3<float64, highp>;
+template struct mat<3, 3, float32, highp>;
+template struct mat<3, 3, float64, highp>;
 
 // tmat3x4 type explicit instantiation
-template struct tmat3x4<float32, lowp>;
-template struct tmat3x4<float64, lowp>;
+template struct mat<3, 4, float32, lowp>;
+template struct mat<3, 4, float64, lowp>;
 
-template struct tmat3x4<float32, mediump>;
-template struct tmat3x4<float64, mediump>;
+template struct mat<3, 4, float32, mediump>;
+template struct mat<3, 4, float64, mediump>;
 
-template struct tmat3x4<float32, highp>;
-template struct tmat3x4<float64, highp>;
+template struct mat<3, 4, float32, highp>;
+template struct mat<3, 4, float64, highp>;
 
 // tmat4x2 type explicit instantiation
-template struct tmat4x2<float32, lowp>;
-template struct tmat4x2<float64, lowp>;
+template struct mat<4, 2, float32, lowp>;
+template struct mat<4, 2, float64, lowp>;
 
-template struct tmat4x2<float32, mediump>;
-template struct tmat4x2<float64, mediump>;
+template struct mat<4, 2, float32, mediump>;
+template struct mat<4, 2, float64, mediump>;
 
-template struct tmat4x2<float32, highp>;
-template struct tmat4x2<float64, highp>;
+template struct mat<4, 2, float32, highp>;
+template struct mat<4, 2, float64, highp>;
 
 // tmat4x3 type explicit instantiation
-template struct tmat4x3<float32, lowp>;
-template struct tmat4x3<float64, lowp>;
+template struct mat<4, 3, float32, lowp>;
+template struct mat<4, 3, float64, lowp>;
 
-template struct tmat4x3<float32, mediump>;
-template struct tmat4x3<float64, mediump>;
+template struct mat<4, 3, float32, mediump>;
+template struct mat<4, 3, float64, mediump>;
 
-template struct tmat4x3<float32, highp>;
-template struct tmat4x3<float64, highp>;
+template struct mat<4, 3, float32, highp>;
+template struct mat<4, 3, float64, highp>;
 
 // tmat4x4 type explicit instantiation
-template struct tmat4x4<float32, lowp>;
-template struct tmat4x4<float64, lowp>;
+template struct mat<4, 4, float32, lowp>;
+template struct mat<4, 4, float64, lowp>;
 
-template struct tmat4x4<float32, mediump>;
-template struct tmat4x4<float64, mediump>;
+template struct mat<4, 4, float32, mediump>;
+template struct mat<4, 4, float64, mediump>;
 
-template struct tmat4x4<float32, highp>;
-template struct tmat4x4<float64, highp>;
+template struct mat<4, 4, float32, highp>;
+template struct mat<4, 4, float64, highp>;
 
 // tquat type explicit instantiation
 template struct tquat<float32, lowp>;
diff --git a/glm/detail/precision.hpp b/glm/detail/precision.hpp
index 7c54437c..86774b26 100644
--- a/glm/detail/precision.hpp
+++ b/glm/detail/precision.hpp
@@ -31,10 +31,13 @@ namespace glm
 			defaultp = highp
 #		endif
 	};
-	
+
+	template<length_t L, typename T, precision P = defaultp> struct vec;
+	template<length_t C, length_t R, typename T, precision P = defaultp> struct mat;
+
 namespace detail
 {
-	template <glm::precision P>
+	template<glm::precision P>
 	struct is_aligned
 	{
 		static const bool value = false;
diff --git a/glm/detail/setup.hpp b/glm/detail/setup.hpp
index 1a22383f..31b1b35b 100644
--- a/glm/detail/setup.hpp
+++ b/glm/detail/setup.hpp
@@ -777,7 +777,7 @@ namespace glm
 #if GLM_HAS_CONSTEXPR_PARTIAL
 	namespace glm
 	{
-		template <typename T, std::size_t N>
+		template<typename T, std::size_t N>
 		constexpr std::size_t countof(T const (&)[N])
 		{
 			return N;
diff --git a/glm/detail/type_gentype.hpp b/glm/detail/type_gentype.hpp
index 8fd202e2..ac9fc019 100644
--- a/glm/detail/type_gentype.hpp
+++ b/glm/detail/type_gentype.hpp
@@ -19,7 +19,7 @@ namespace detail
 	template
 	<
 		typename VALTYPE, 
-		template <typename> class TYPE
+		template<typename> class TYPE
 	>
 	struct genType
 	{
@@ -65,14 +65,14 @@ namespace detail
 	template
 	<
 		typename VALTYPE, 
-		template <typename> class TYPE
+		template<typename> class TYPE
 	>
 	bool genType<VALTYPE, TYPE>::is_vector()
 	{
 		return true;
 	}
 /*
-	template <typename valTypeT, unsigned int colT, unsigned int rowT, profile proT = nice>
+	template<typename valTypeT, unsigned int colT, unsigned int rowT, profile proT = nice>
 	class base
 	{
 	public:
@@ -112,7 +112,7 @@ namespace detail
 
 		//////////////////////////////////////
 		// Conversions
-		template <typename vU, uint cU, uint rU, profile pU>
+		template<typename vU, uint cU, uint rU, profile pU>
 		explicit base(base<vU, cU, rU, pU> const & m);
 
 		//////////////////////////////////////
@@ -136,7 +136,7 @@ namespace detail
 	};
 */
 	
-	//template <typename T>
+	//template<typename T>
 	//struct traits
 	//{
 	//	static const bool is_signed = false;
@@ -148,28 +148,28 @@ namespace detail
 	//	static const bool is_genUType = false;
 	//};
 	
-	//template <>
+	//template<>
 	//struct traits<half>
 	//{
 	//	static const bool is_float = true;
 	//	static const bool is_genType = true;
 	//};
 	
-	//template <>
+	//template<>
 	//struct traits<float>
 	//{
 	//	static const bool is_float = true;
 	//	static const bool is_genType = true;
 	//};
 	
-	//template <>
+	//template<>
 	//struct traits<double>
 	//{
 	//	static const bool is_float = true;
 	//	static const bool is_genType = true;
 	//};
 	
-	//template <typename genType>
+	//template<typename genType>
 	//struct desc
 	//{
 	//	typedef genType							type;
@@ -186,7 +186,7 @@ namespace detail
 	//	static const typename size_type			value_size;
 	//};
 	
-	//template <typename genType>
+	//template<typename genType>
 	//const typename desc<genType>::size_type desc<genType>::value_size = genType::value_size();
 	
 }//namespace detail
diff --git a/glm/detail/type_gentype.inl b/glm/detail/type_gentype.inl
index 6a90288e..384f725f 100644
--- a/glm/detail/type_gentype.inl
+++ b/glm/detail/type_gentype.inl
@@ -7,37 +7,37 @@ namespace detail{
 /////////////////////////////////
 // Static functions
 
-template <typename vT, uint cT, uint rT, profile pT>
+template<typename vT, uint cT, uint rT, profile pT>
 typename base<vT, cT, rT, pT>::size_type base<vT, cT, rT, pT>::col_size()
 {
 	return cT;
 }
 
-template <typename vT, uint cT, uint rT, profile pT>
+template<typename vT, uint cT, uint rT, profile pT>
 typename base<vT, cT, rT, pT>::size_type base<vT, cT, rT, pT>::row_size()
 {
 	return rT;
 }
 
-template <typename vT, uint cT, uint rT, profile pT>
+template<typename vT, uint cT, uint rT, profile pT>
 typename base<vT, cT, rT, pT>::size_type base<vT, cT, rT, pT>::value_size()
 {
 	return rT * cT;
 }
 
-template <typename vT, uint cT, uint rT, profile pT>
+template<typename vT, uint cT, uint rT, profile pT>
 bool base<vT, cT, rT, pT>::is_scalar()
 {
 	return rT == 1 && cT == 1;
 }
 
-template <typename vT, uint cT, uint rT, profile pT>
+template<typename vT, uint cT, uint rT, profile pT>
 bool base<vT, cT, rT, pT>::is_vector()
 {
 	return rT == 1;
 }
 
-template <typename vT, uint cT, uint rT, profile pT>
+template<typename vT, uint cT, uint rT, profile pT>
 bool base<vT, cT, rT, pT>::is_matrix()
 {
 	return rT != 1;
@@ -46,13 +46,13 @@ bool base<vT, cT, rT, pT>::is_matrix()
 /////////////////////////////////
 // Constructor
 
-template <typename vT, uint cT, uint rT, profile pT>
+template<typename vT, uint cT, uint rT, profile pT>
 base<vT, cT, rT, pT>::base()
 {
 	memset(&this->value, 0, cT * rT * sizeof(vT));
 }
 
-template <typename vT, uint cT, uint rT, profile pT>
+template<typename vT, uint cT, uint rT, profile pT>
 base<vT, cT, rT, pT>::base
 (
 	typename base<vT, cT, rT, pT>::class_type const & m
@@ -69,7 +69,7 @@ base<vT, cT, rT, pT>::base
 	}
 }
 
-template <typename vT, uint cT, uint rT, profile pT>
+template<typename vT, uint cT, uint rT, profile pT>
 base<vT, cT, rT, pT>::base
 (
 	typename base<vT, cT, rT, pT>::T const & x
@@ -105,7 +105,7 @@ base<vT, cT, rT, pT>::base
 	}
 }
 
-template <typename vT, uint cT, uint rT, profile pT>
+template<typename vT, uint cT, uint rT, profile pT>
 base<vT, cT, rT, pT>::base
 (
 	typename base<vT, cT, rT, pT>::value_type const * const x
@@ -114,7 +114,7 @@ base<vT, cT, rT, pT>::base
 	memcpy(&this->value, &x.value, cT * rT * sizeof(vT));
 }
 
-template <typename vT, uint cT, uint rT, profile pT>
+template<typename vT, uint cT, uint rT, profile pT>
 base<vT, cT, rT, pT>::base
 (
 	typename base<vT, cT, rT, pT>::col_type const * const x
@@ -131,8 +131,8 @@ base<vT, cT, rT, pT>::base
 	}
 }
 
-template <typename vT, uint cT, uint rT, profile pT>
-template <typename vU, uint cU, uint rU, profile pU>
+template<typename vT, uint cT, uint rT, profile pT>
+template<typename vU, uint cU, uint rU, profile pU>
 base<vT, cT, rT, pT>::base
 (
 	base<vU, cU, rU, pU> const & m
@@ -152,7 +152,7 @@ base<vT, cT, rT, pT>::base
 //////////////////////////////////////
 // Accesses
 
-template <typename vT, uint cT, uint rT, profile pT>
+template<typename vT, uint cT, uint rT, profile pT>
 typename base<vT, cT, rT, pT>::col_type& base<vT, cT, rT, pT>::operator[]
 (
 	typename base<vT, cT, rT, pT>::size_type i
@@ -161,7 +161,7 @@ typename base<vT, cT, rT, pT>::col_type& base<vT, cT, rT, pT>::operator[]
 	return this->value[i];
 }
 
-template <typename vT, uint cT, uint rT, profile pT>
+template<typename vT, uint cT, uint rT, profile pT>
 typename base<vT, cT, rT, pT>::col_type const & base<vT, cT, rT, pT>::operator[]
 (
 	typename base<vT, cT, rT, pT>::size_type i
@@ -173,7 +173,7 @@ typename base<vT, cT, rT, pT>::col_type const & base<vT, cT, rT, pT>::operator[]
 //////////////////////////////////////
 // Unary updatable operators
 
-template <typename vT, uint cT, uint rT, profile pT>
+template<typename vT, uint cT, uint rT, profile pT>
 typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator= 
 (
 	typename base<vT, cT, rT, pT>::class_type const & x
@@ -183,7 +183,7 @@ typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator=
 	return *this;
 }
 
-template <typename vT, uint cT, uint rT, profile pT>
+template<typename vT, uint cT, uint rT, profile pT>
 typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator+= 
 (
 	typename base<vT, cT, rT, pT>::T const & x
@@ -199,7 +199,7 @@ typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator+=
 	return *this;
 }
 
-template <typename vT, uint cT, uint rT, profile pT>
+template<typename vT, uint cT, uint rT, profile pT>
 typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator+= 
 (
 	typename base<vT, cT, rT, pT>::class_type const & x
@@ -215,7 +215,7 @@ typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator+=
 	return *this;
 }
 
-template <typename vT, uint cT, uint rT, profile pT>
+template<typename vT, uint cT, uint rT, profile pT>
 typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator-= 
 (
 	typename base<vT, cT, rT, pT>::T const & x
@@ -231,7 +231,7 @@ typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator-=
 	return *this;
 }
 
-template <typename vT, uint cT, uint rT, profile pT>
+template<typename vT, uint cT, uint rT, profile pT>
 typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator-= 
 (
 	typename base<vT, cT, rT, pT>::class_type const & x
@@ -247,7 +247,7 @@ typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator-=
 	return *this;
 }
 
-template <typename vT, uint cT, uint rT, profile pT>
+template<typename vT, uint cT, uint rT, profile pT>
 typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator*= 
 (
 	typename base<vT, cT, rT, pT>::T const & x
@@ -263,7 +263,7 @@ typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator*=
 	return *this;
 }
 
-template <typename vT, uint cT, uint rT, profile pT>
+template<typename vT, uint cT, uint rT, profile pT>
 typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator*= 
 (
 	typename base<vT, cT, rT, pT>::class_type const & x
@@ -279,7 +279,7 @@ typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator*=
 	return *this;
 }
 
-template <typename vT, uint cT, uint rT, profile pT>
+template<typename vT, uint cT, uint rT, profile pT>
 typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator/= 
 (
 	typename base<vT, cT, rT, pT>::T const & x
@@ -295,7 +295,7 @@ typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator/=
 	return *this;
 }
 
-template <typename vT, uint cT, uint rT, profile pT>
+template<typename vT, uint cT, uint rT, profile pT>
 typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator/= 
 (
 	typename base<vT, cT, rT, pT>::class_type const & x
@@ -311,7 +311,7 @@ typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator/=
 	return *this;
 }
 
-template <typename vT, uint cT, uint rT, profile pT>
+template<typename vT, uint cT, uint rT, profile pT>
 typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator++ ()
 {
 	typename base<vT, cT, rT, pT>::size_type stop_col = col_size();
@@ -324,7 +324,7 @@ typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator++ ()
 	return *this;
 }
 
-template <typename vT, uint cT, uint rT, profile pT>
+template<typename vT, uint cT, uint rT, profile pT>
 typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator-- ()
 {
 	typename base<vT, cT, rT, pT>::size_type stop_col = col_size();
diff --git a/glm/detail/type_int.hpp b/glm/detail/type_int.hpp
index 764a32cf..36feb16a 100644
--- a/glm/detail/type_int.hpp
+++ b/glm/detail/type_int.hpp
@@ -73,129 +73,129 @@ namespace detail
 		using std::make_unsigned;
 
 #	else//GLM_HAS_MAKE_SIGNED
-		template <typename genType>
+		template<typename genType>
 		struct make_signed
 		{};
 
-		template <>
+		template<>
 		struct make_signed<char>
 		{
 			typedef char type;
 		};
 
-		template <>
+		template<>
 		struct make_signed<short>
 		{
 			typedef short type;
 		};
 
-		template <>
+		template<>
 		struct make_signed<int>
 		{
 			typedef int type;
 		};
 
-		template <>
+		template<>
 		struct make_signed<long>
 		{
 			typedef long type;
 		};
 	
-		template <>
+		template<>
 		struct make_signed<unsigned char>
 		{
 			typedef char type;
 		};
 
-		template <>
+		template<>
 		struct make_signed<unsigned short>
 		{
 			typedef short type;
 		};
 
-		template <>
+		template<>
 		struct make_signed<unsigned int>
 		{
 			typedef int type;
 		};
 
-		template <>
+		template<>
 		struct make_signed<unsigned long>
 		{
 			typedef long type;
 		};
 
-		template <typename genType>
+		template<typename genType>
 		struct make_unsigned
 		{};
 
-		template <>
+		template<>
 		struct make_unsigned<char>
 		{
 			typedef unsigned char type;
 		};
 
-		template <>
+		template<>
 		struct make_unsigned<short>
 		{
 			typedef unsigned short type;
 		};
 
-		template <>
+		template<>
 		struct make_unsigned<int>
 		{
 			typedef unsigned int type;
 		};
 
-		template <>
+		template<>
 		struct make_unsigned<long>
 		{
 			typedef unsigned long type;
 		};
 
-		template <>
+		template<>
 		struct make_unsigned<unsigned char>
 		{
 			typedef unsigned char type;
 		};
 
-		template <>
+		template<>
 		struct make_unsigned<unsigned short>
 		{
 			typedef unsigned short type;
 		};
 
-		template <>
+		template<>
 		struct make_unsigned<unsigned int>
 		{
 			typedef unsigned int type;
 		};
 
-		template <>
+		template<>
 		struct make_unsigned<unsigned long>
 		{
 			typedef unsigned long type;
 		};
 
-		template <>
+		template<>
 		struct make_signed<long long>
 		{
 			typedef long long type;
 		};
 	
-		template <>
+		template<>
 		struct make_signed<unsigned long long>
 		{
 			typedef long long type;
 		};
 	
-		template <>
+		template<>
 		struct make_unsigned<long long>
 		{
 			typedef unsigned long long type;
 		};
 	
-		template <>
+		template<>
 		struct make_unsigned<unsigned long long>
 		{
 			typedef unsigned long long type;
diff --git a/glm/detail/type_mat.hpp b/glm/detail/type_mat.hpp
index aad74e5b..677ce605 100644
--- a/glm/detail/type_mat.hpp
+++ b/glm/detail/type_mat.hpp
@@ -8,24 +8,11 @@
 namespace glm{
 namespace detail
 {
-	template <typename T, precision P, template <class, precision> class colType, template <class, precision> class rowType>
+	template<int Columns, int Rows, typename T, precision P, template<int, class, precision> class colType, template<int, class, precision> class rowType>
 	struct outerProduct_trait{};
 }//namespace detail
 
-	template <typename T, precision P> struct tvec2;
-	template <typename T, precision P> struct tvec3;
-	template <typename T, precision P> struct tvec4;
-	template <typename T, precision P> struct tmat2x2;
-	template <typename T, precision P> struct tmat2x3;
-	template <typename T, precision P> struct tmat2x4;
-	template <typename T, precision P> struct tmat3x2;
-	template <typename T, precision P> struct tmat3x3;
-	template <typename T, precision P> struct tmat3x4;
-	template <typename T, precision P> struct tmat4x2;
-	template <typename T, precision P> struct tmat4x3;
-	template <typename T, precision P> struct tmat4x4;
-
-	template <typename T, precision P, template <typename, precision> class matType>
+	template<typename T, precision P, template<typename, precision> class matType>
 	GLM_FUNC_DECL matType<T, P> inverse(matType<T, P> const & m);
 
 	/// @addtogroup core_precision
@@ -36,42 +23,42 @@ namespace detail
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat2x2<float, lowp>		lowp_mat2;
+	typedef mat<2, 2, float, lowp>		lowp_mat2;
 	
 	/// 2 columns of 2 components matrix of medium precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat2x2<float, mediump>		mediump_mat2;
+	typedef mat<2, 2, float, mediump>	mediump_mat2;
 	
 	/// 2 columns of 2 components matrix of high precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat2x2<float, highp>		highp_mat2;
+	typedef mat<2, 2, float, highp>		highp_mat2;
 	
 	/// 2 columns of 2 components matrix of low precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat2x2<float, lowp>		lowp_mat2x2;
+	typedef mat<2, 2, float, lowp>		lowp_mat2x2;
 	
 	/// 2 columns of 2 components matrix of medium precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat2x2<float, mediump>		mediump_mat2x2;
+	typedef mat<2, 2, float, mediump>	mediump_mat2x2;
 	
 	/// 2 columns of 2 components matrix of high precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat2x2<float, highp>		highp_mat2x2;
+	typedef mat<2, 2, float, highp>		highp_mat2x2;
 	
 	/// @}
 	
@@ -83,21 +70,21 @@ namespace detail
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat2x3<float, lowp>		lowp_mat2x3;
+	typedef mat<2, 3, float, lowp>		lowp_mat2x3;
 	
 	/// 2 columns of 3 components matrix of medium precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat2x3<float, mediump>		mediump_mat2x3;
+	typedef mat<2, 3, float, mediump>	mediump_mat2x3;
 	
 	/// 2 columns of 3 components matrix of high precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat2x3<float, highp>		highp_mat2x3;
+	typedef mat<2, 3, float, highp>		highp_mat2x3;
 	
 	/// @}
 	
@@ -109,21 +96,21 @@ namespace detail
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat2x4<float, lowp>		lowp_mat2x4;
+	typedef mat<2, 4, float, lowp>		lowp_mat2x4;
 	
 	/// 2 columns of 4 components matrix of medium precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat2x4<float, mediump>		mediump_mat2x4;
+	typedef mat<2, 4, float, mediump>	mediump_mat2x4;
 	
 	/// 2 columns of 4 components matrix of high precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat2x4<float, highp>		highp_mat2x4;
+	typedef mat<2, 4, float, highp>		highp_mat2x4;
 	
 	/// @}
 	
@@ -135,21 +122,21 @@ namespace detail
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat3x2<float, lowp>		lowp_mat3x2;
+	typedef mat<3, 2, float, lowp>		lowp_mat3x2;
 	
 	/// 3 columns of 2 components matrix of medium precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat3x2<float, mediump>		mediump_mat3x2;
+	typedef mat<3, 2, float, mediump>	mediump_mat3x2;
 	
 	/// 3 columns of 2 components matrix of high precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat3x2<float, highp>		highp_mat3x2;
+	typedef mat<3, 2, float, highp>		highp_mat3x2;
 	
 	/// @}
 	
@@ -161,42 +148,42 @@ namespace detail
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat3x3<float, lowp>		lowp_mat3;
+	typedef mat<3, 3, float, lowp>		lowp_mat3;
 	
 	/// 3 columns of 3 components matrix of medium precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat3x3<float, mediump>		mediump_mat3;
+	typedef mat<3, 3, float, mediump>	mediump_mat3;
 	
 	/// 3 columns of 3 components matrix of high precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat3x3<float, highp>		highp_mat3;
+	typedef mat<3, 3, float, highp>		highp_mat3;
 	
 	/// 3 columns of 3 components matrix of low precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat3x3<float, lowp>		lowp_mat3x3;
+	typedef mat<3, 3, float, lowp>		lowp_mat3x3;
 	
 	/// 3 columns of 3 components matrix of medium precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat3x3<float, mediump>		mediump_mat3x3;
+	typedef mat<3, 3, float, mediump>	mediump_mat3x3;
 	
 	/// 3 columns of 3 components matrix of high precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat3x3<float, highp>		highp_mat3x3;
+	typedef mat<3, 3, float, highp>		highp_mat3x3;
 	
 	/// @}
 	
@@ -208,21 +195,21 @@ namespace detail
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat3x4<float, lowp>		lowp_mat3x4;
+	typedef mat<3, 4, float, lowp>		lowp_mat3x4;
 	
 	/// 3 columns of 4 components matrix of medium precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat3x4<float, mediump>		mediump_mat3x4;
+	typedef mat<3, 4, float, mediump>	mediump_mat3x4;
 	
 	/// 3 columns of 4 components matrix of high precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat3x4<float, highp>		highp_mat3x4;
+	typedef mat<3, 4, float, highp>		highp_mat3x4;
 	
 	/// @}
 	
@@ -234,21 +221,21 @@ namespace detail
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat4x2<float, lowp>		lowp_mat4x2;
+	typedef mat<4, 2, float, lowp>		lowp_mat4x2;
 	
 	/// 4 columns of 2 components matrix of medium precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat4x2<float, mediump>		mediump_mat4x2;
+	typedef mat<4, 2, float, mediump>	mediump_mat4x2;
 	
 	/// 4 columns of 2 components matrix of high precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat4x2<float, highp>		highp_mat4x2;
+	typedef mat<4, 2, float, highp>		highp_mat4x2;
 	
 	/// @}
 	
@@ -260,21 +247,21 @@ namespace detail
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat4x3<float, lowp>		lowp_mat4x3;
+	typedef mat<4, 3, float, lowp>		lowp_mat4x3;
 	
 	/// 4 columns of 3 components matrix of medium precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat4x3<float, mediump>		mediump_mat4x3;
+	typedef mat<4, 3, float, mediump>	mediump_mat4x3;
 	
 	/// 4 columns of 3 components matrix of high precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat4x3<float, highp>		highp_mat4x3;
+	typedef mat<4, 3, float, highp>		highp_mat4x3;
 	
 	/// @}
 	
@@ -287,42 +274,42 @@ namespace detail
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat4x4<float, lowp>		lowp_mat4;
+	typedef mat<4, 4, float, lowp>		lowp_mat4;
 	
 	/// 4 columns of 4 components matrix of medium precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat4x4<float, mediump>		mediump_mat4;
+	typedef mat<4, 4, float, mediump>	mediump_mat4;
 	
 	/// 4 columns of 4 components matrix of high precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat4x4<float, highp>		highp_mat4;
+	typedef mat<4, 4, float, highp>		highp_mat4;
 	
 	/// 4 columns of 4 components matrix of low precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat4x4<float, lowp>		lowp_mat4x4;
+	typedef mat<4, 4, float, lowp>		lowp_mat4x4;
 	
 	/// 4 columns of 4 components matrix of medium precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat4x4<float, mediump>		mediump_mat4x4;
+	typedef mat<4, 4, float, mediump>	mediump_mat4x4;
 	
 	/// 4 columns of 4 components matrix of high precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat4x4<float, highp>		highp_mat4x4;
+	typedef mat<4, 4, float, highp>		highp_mat4x4;
 	
 	/// @}
 	
@@ -425,37 +412,37 @@ namespace detail
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat2x2<double, lowp>		lowp_dmat2;
+	typedef mat<2, 2, double, lowp>		lowp_dmat2;
 	
 	/// 2 columns of 2 components matrix of medium precision floating-point numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat2x2<double, mediump>	mediump_dmat2;
+	typedef mat<2, 2, double, mediump>	mediump_dmat2;
 	
 	/// 2 columns of 2 components matrix of high precision floating-point numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat2x2<double, highp>		highp_dmat2;
+	typedef mat<2, 2, double, highp>		highp_dmat2;
 	
 	/// 2 columns of 2 components matrix of low precision floating-point numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat2x2<double, lowp>		lowp_dmat2x2;
+	typedef mat<2, 2, double, lowp>		lowp_dmat2x2;
 	
 	/// 2 columns of 2 components matrix of medium precision floating-point numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat2x2<double, mediump>	mediump_dmat2x2;
+	typedef mat<2, 2, double, mediump>	mediump_dmat2x2;
 	
 	/// 2 columns of 2 components matrix of high precision floating-point numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat2x2<double, highp>		highp_dmat2x2;
+	typedef mat<2, 2, double, highp>		highp_dmat2x2;
 	
 	/// @}
 	
@@ -466,19 +453,19 @@ namespace detail
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat2x3<double, lowp>		lowp_dmat2x3;
+	typedef mat<2, 3, double, lowp>		lowp_dmat2x3;
 	
 	/// 2 columns of 3 components matrix of medium precision floating-point numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat2x3<double, mediump>	mediump_dmat2x3;
+	typedef mat<2, 3, double, mediump>	mediump_dmat2x3;
 	
 	/// 2 columns of 3 components matrix of high precision floating-point numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat2x3<double, highp>		highp_dmat2x3;
+	typedef mat<2, 3, double, highp>		highp_dmat2x3;
 	
 	/// @}
 	
@@ -489,19 +476,19 @@ namespace detail
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat2x4<double, lowp>		lowp_dmat2x4;
+	typedef mat<2, 4, double, lowp>		lowp_dmat2x4;
 	
 	/// 2 columns of 4 components matrix of medium precision floating-point numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat2x4<double, mediump>	mediump_dmat2x4;
+	typedef mat<2, 4, double, mediump>	mediump_dmat2x4;
 	
 	/// 2 columns of 4 components matrix of high precision floating-point numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat2x4<double, highp>		highp_dmat2x4;
+	typedef mat<2, 4, double, highp>		highp_dmat2x4;
 	
 	/// @}
 	
@@ -512,19 +499,19 @@ namespace detail
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat3x2<double, lowp>		lowp_dmat3x2;
+	typedef mat<3, 2, double, lowp>		lowp_dmat3x2;
 	
 	/// 3 columns of 2 components matrix of medium precision floating-point numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat3x2<double, mediump>	mediump_dmat3x2;
+	typedef mat<3, 2, double, mediump>	mediump_dmat3x2;
 	
 	/// 3 columns of 2 components matrix of high precision floating-point numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat3x2<double, highp>		highp_dmat3x2;
+	typedef mat<3, 2, double, highp>		highp_dmat3x2;
 	
 	/// @}
 	
@@ -535,37 +522,37 @@ namespace detail
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat3x3<float, lowp>		lowp_dmat3;
+	typedef mat<3, 3, float, lowp>		lowp_dmat3;
 	
 	/// 3 columns of 3 components matrix of medium precision floating-point numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat3x3<double, mediump>	mediump_dmat3;
+	typedef mat<3, 3, double, mediump>	mediump_dmat3;
 	
 	/// 3 columns of 3 components matrix of high precision floating-point numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat3x3<double, highp>		highp_dmat3;
+	typedef mat<3, 3, double, highp>		highp_dmat3;
 	
 	/// 3 columns of 3 components matrix of low precision floating-point numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat3x3<double, lowp>		lowp_dmat3x3;
+	typedef mat<3, 3, double, lowp>		lowp_dmat3x3;
 	
 	/// 3 columns of 3 components matrix of medium precision floating-point numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat3x3<double, mediump>	mediump_dmat3x3;
+	typedef mat<3, 3, double, mediump>	mediump_dmat3x3;
 	
 	/// 3 columns of 3 components matrix of high precision floating-point numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat3x3<double, highp>		highp_dmat3x3;
+	typedef mat<3, 3, double, highp>		highp_dmat3x3;
 	
 	/// @}
 	
@@ -576,19 +563,19 @@ namespace detail
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat3x4<double, lowp>		lowp_dmat3x4;
+	typedef mat<3, 4, double, lowp>		lowp_dmat3x4;
 	
 	/// 3 columns of 4 components matrix of medium precision floating-point numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat3x4<double, mediump>	mediump_dmat3x4;
+	typedef mat<3, 4, double, mediump>	mediump_dmat3x4;
 	
 	/// 3 columns of 4 components matrix of high precision floating-point numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat3x4<double, highp>		highp_dmat3x4;
+	typedef mat<3, 4, double, highp>		highp_dmat3x4;
 	
 	/// @}
 	
@@ -599,19 +586,19 @@ namespace detail
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat4x2<double, lowp>		lowp_dmat4x2;
+	typedef mat<4, 2, double, lowp>		lowp_dmat4x2;
 	
 	/// 4 columns of 2 components matrix of medium precision floating-point numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat4x2<double, mediump>	mediump_dmat4x2;
+	typedef mat<4, 2, double, mediump>	mediump_dmat4x2;
 	
 	/// 4 columns of 2 components matrix of high precision floating-point numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat4x2<double, highp>		highp_dmat4x2;
+	typedef mat<4, 2, double, highp>		highp_dmat4x2;
 	
 	/// @}
 	
@@ -622,19 +609,19 @@ namespace detail
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat4x3<double, lowp>		lowp_dmat4x3;
+	typedef mat<4, 3, double, lowp>		lowp_dmat4x3;
 	
 	/// 4 columns of 3 components matrix of medium precision floating-point numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat4x3<double, mediump>	mediump_dmat4x3;
+	typedef mat<4, 3, double, mediump>	mediump_dmat4x3;
 	
 	/// 4 columns of 3 components matrix of high precision floating-point numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat4x3<double, highp>		highp_dmat4x3;
+	typedef mat<4, 3, double, highp>		highp_dmat4x3;
 	
 	/// @}
 	
@@ -645,37 +632,37 @@ namespace detail
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat4x4<double, lowp>		lowp_dmat4;
+	typedef mat<4, 4, double, lowp>		lowp_dmat4;
 	
 	/// 4 columns of 4 components matrix of medium precision floating-point numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat4x4<double, mediump>	mediump_dmat4;
+	typedef mat<4, 4, double, mediump>	mediump_dmat4;
 	
 	/// 4 columns of 4 components matrix of high precision floating-point numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat4x4<double, highp>		highp_dmat4;
+	typedef mat<4, 4, double, highp>		highp_dmat4;
 	
 	/// 4 columns of 4 components matrix of low precision floating-point numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat4x4<double, lowp>		lowp_dmat4x4;
+	typedef mat<4, 4, double, lowp>		lowp_dmat4x4;
 	
 	/// 4 columns of 4 components matrix of medium precision floating-point numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat4x4<double, mediump>	mediump_dmat4x4;
+	typedef mat<4, 4, double, mediump>	mediump_dmat4x4;
 	
 	/// 4 columns of 4 components matrix of high precision floating-point numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat4x4<double, highp>		highp_dmat4x4;
+	typedef mat<4, 4, double, highp>		highp_dmat4x4;
 	
 	/// @}
 	
diff --git a/glm/detail/type_mat2x2.hpp b/glm/detail/type_mat2x2.hpp
index e7fde26f..4d86b72a 100644
--- a/glm/detail/type_mat2x2.hpp
+++ b/glm/detail/type_mat2x2.hpp
@@ -11,13 +11,13 @@
 
 namespace glm
 {
-	template <typename T, precision P = defaultp>
-	struct tmat2x2
+	template<typename T, precision P>
+	struct mat<2, 2, T, P>
 	{
-		typedef tvec2<T, P> col_type;
-		typedef tvec2<T, P> row_type;
-		typedef tmat2x2<T, P> type;
-		typedef tmat2x2<T, P> transpose_type;
+		typedef vec<2, T, P> col_type;
+		typedef vec<2, T, P> row_type;
+		typedef mat<2, 2, T, P> type;
+		typedef mat<2, 2, T, P> transpose_type;
 		typedef T value_type;
 
 	private:
@@ -26,45 +26,45 @@ namespace glm
 	public:
 		// -- Constructors --
 
-		GLM_FUNC_DECL tmat2x2() GLM_DEFAULT_CTOR;
-		GLM_FUNC_DECL tmat2x2(tmat2x2<T, P> const & m) GLM_DEFAULT;
-		template <precision Q>
-		GLM_FUNC_DECL tmat2x2(tmat2x2<T, Q> const & m);
+		GLM_FUNC_DECL mat() GLM_DEFAULT_CTOR;
+		GLM_FUNC_DECL mat(mat<2, 2, T, P> const & m) GLM_DEFAULT;
+		template<precision Q>
+		GLM_FUNC_DECL mat(mat<2, 2, T, Q> const & m);
 
-		GLM_FUNC_DECL GLM_CONSTEXPR_CTOR explicit tmat2x2(ctor);
-		GLM_FUNC_DECL explicit tmat2x2(T scalar);
-		GLM_FUNC_DECL tmat2x2(
+		GLM_FUNC_DECL GLM_CONSTEXPR_CTOR explicit mat(ctor);
+		GLM_FUNC_DECL explicit mat(T scalar);
+		GLM_FUNC_DECL mat(
 			T const & x1, T const & y1,
 			T const & x2, T const & y2);
-		GLM_FUNC_DECL tmat2x2(
+		GLM_FUNC_DECL mat(
 			col_type const & v1,
 			col_type const & v2);
 
 		// -- Conversions --
 
-		template <typename U, typename V, typename M, typename N>
-		GLM_FUNC_DECL tmat2x2(
+		template<typename U, typename V, typename M, typename N>
+		GLM_FUNC_DECL mat(
 			U const & x1, V const & y1,
 			M const & x2, N const & y2);
 
-		template <typename U, typename V>
-		GLM_FUNC_DECL tmat2x2(
-			tvec2<U, P> const & v1,
-			tvec2<V, P> const & v2);
+		template<typename U, typename V>
+		GLM_FUNC_DECL mat(
+			vec<2, U, P> const & v1,
+			vec<2, V, P> const & v2);
 
 		// -- Matrix conversions --
 
-		template <typename U, precision Q>
-		GLM_FUNC_DECL GLM_EXPLICIT tmat2x2(tmat2x2<U, Q> const & m);
+		template<typename U, precision Q>
+		GLM_FUNC_DECL GLM_EXPLICIT mat(mat<2, 2, U, Q> const & m);
 
-		GLM_FUNC_DECL GLM_EXPLICIT tmat2x2(tmat3x3<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat2x2(tmat4x4<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat2x2(tmat2x3<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat2x2(tmat3x2<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat2x2(tmat2x4<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat2x2(tmat4x2<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat2x2(tmat3x4<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat2x2(tmat4x3<T, P> const & x);
+		GLM_FUNC_DECL GLM_EXPLICIT mat(mat<3, 3, T, P> const & x);
+		GLM_FUNC_DECL GLM_EXPLICIT mat(mat<4, 4, T, P> const & x);
+		GLM_FUNC_DECL GLM_EXPLICIT mat(mat<2, 3, T, P> const & x);
+		GLM_FUNC_DECL GLM_EXPLICIT mat(mat<3, 2, T, P> const & x);
+		GLM_FUNC_DECL GLM_EXPLICIT mat(mat<2, 4, T, P> const & x);
+		GLM_FUNC_DECL GLM_EXPLICIT mat(mat<4, 2, T, P> const & x);
+		GLM_FUNC_DECL GLM_EXPLICIT mat(mat<3, 4, T, P> const & x);
+		GLM_FUNC_DECL GLM_EXPLICIT mat(mat<4, 3, T, P> const & x);
 
 		// -- Accesses --
 
@@ -76,106 +76,106 @@ namespace glm
 
 		// -- Unary arithmetic operators --
 
-		GLM_FUNC_DECL tmat2x2<T, P> & operator=(tmat2x2<T, P> const & v) GLM_DEFAULT;
+		GLM_FUNC_DECL mat<2, 2, T, P> & operator=(mat<2, 2, T, P> const & v) GLM_DEFAULT;
 
-		template <typename U>
-		GLM_FUNC_DECL tmat2x2<T, P> & operator=(tmat2x2<U, P> const & m);
-		template <typename U>
-		GLM_FUNC_DECL tmat2x2<T, P> & operator+=(U s);
-		template <typename U>
-		GLM_FUNC_DECL tmat2x2<T, P> & operator+=(tmat2x2<U, P> const & m);
-		template <typename U>
-		GLM_FUNC_DECL tmat2x2<T, P> & operator-=(U s);
-		template <typename U>
-		GLM_FUNC_DECL tmat2x2<T, P> & operator-=(tmat2x2<U, P> const & m);
-		template <typename U>
-		GLM_FUNC_DECL tmat2x2<T, P> & operator*=(U s);
-		template <typename U>
-		GLM_FUNC_DECL tmat2x2<T, P> & operator*=(tmat2x2<U, P> const & m);
-		template <typename U>
-		GLM_FUNC_DECL tmat2x2<T, P> & operator/=(U s);
-		template <typename U>
-		GLM_FUNC_DECL tmat2x2<T, P> & operator/=(tmat2x2<U, P> const & m);
+		template<typename U>
+		GLM_FUNC_DECL mat<2, 2, T, P> & operator=(mat<2, 2, U, P> const & m);
+		template<typename U>
+		GLM_FUNC_DECL mat<2, 2, T, P> & operator+=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<2, 2, T, P> & operator+=(mat<2, 2, U, P> const & m);
+		template<typename U>
+		GLM_FUNC_DECL mat<2, 2, T, P> & operator-=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<2, 2, T, P> & operator-=(mat<2, 2, U, P> const & m);
+		template<typename U>
+		GLM_FUNC_DECL mat<2, 2, T, P> & operator*=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<2, 2, T, P> & operator*=(mat<2, 2, U, P> const & m);
+		template<typename U>
+		GLM_FUNC_DECL mat<2, 2, T, P> & operator/=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<2, 2, T, P> & operator/=(mat<2, 2, U, P> const & m);
 
 		// -- Increment and decrement operators --
 
-		GLM_FUNC_DECL tmat2x2<T, P> & operator++ ();
-		GLM_FUNC_DECL tmat2x2<T, P> & operator-- ();
-		GLM_FUNC_DECL tmat2x2<T, P> operator++(int);
-		GLM_FUNC_DECL tmat2x2<T, P> operator--(int);
+		GLM_FUNC_DECL mat<2, 2, T, P> & operator++ ();
+		GLM_FUNC_DECL mat<2, 2, T, P> & operator-- ();
+		GLM_FUNC_DECL mat<2, 2, T, P> operator++(int);
+		GLM_FUNC_DECL mat<2, 2, T, P> operator--(int);
 	};
 
 	// -- Unary operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x2<T, P> operator+(tmat2x2<T, P> const & m);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<2, 2, T, P> operator+(mat<2, 2, T, P> const & m);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x2<T, P> operator-(tmat2x2<T, P> const & m);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<2, 2, T, P> operator-(mat<2, 2, T, P> const & m);
 
 	// -- Binary operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x2<T, P> operator+(tmat2x2<T, P> const & m, T scalar);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<2, 2, T, P> operator+(mat<2, 2, T, P> const & m, T scalar);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x2<T, P> operator+(T scalar, tmat2x2<T, P> const & m);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<2, 2, T, P> operator+(T scalar, mat<2, 2, T, P> const & m);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x2<T, P> operator+(tmat2x2<T, P> const & m1, tmat2x2<T, P> const & m2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<2, 2, T, P> operator+(mat<2, 2, T, P> const & m1, mat<2, 2, T, P> const & m2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x2<T, P> operator-(tmat2x2<T, P> const & m, T scalar);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<2, 2, T, P> operator-(mat<2, 2, T, P> const & m, T scalar);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x2<T, P> operator-(T scalar, tmat2x2<T, P> const & m);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<2, 2, T, P> operator-(T scalar, mat<2, 2, T, P> const & m);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x2<T, P> operator-(tmat2x2<T, P> const & m1, tmat2x2<T, P> const & m2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<2, 2, T, P> operator-(mat<2, 2, T, P> const & m1, mat<2, 2, T, P> const & m2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x2<T, P> operator*(tmat2x2<T, P> const & m, T scalar);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<2, 2, T, P> operator*(mat<2, 2, T, P> const & m, T scalar);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x2<T, P> operator*(T scalar, tmat2x2<T, P> const & m);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<2, 2, T, P> operator*(T scalar, mat<2, 2, T, P> const & m);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL typename tmat2x2<T, P>::col_type operator*(tmat2x2<T, P> const & m, typename tmat2x2<T, P>::row_type const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL typename mat<2, 2, T, P>::col_type operator*(mat<2, 2, T, P> const & m, typename mat<2, 2, T, P>::row_type const & v);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL typename tmat2x2<T, P>::row_type operator*(typename tmat2x2<T, P>::col_type const & v, tmat2x2<T, P> const & m);
+	template<typename T, precision P>
+	GLM_FUNC_DECL typename mat<2, 2, T, P>::row_type operator*(typename mat<2, 2, T, P>::col_type const & v, mat<2, 2, T, P> const & m);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x2<T, P> operator*(tmat2x2<T, P> const & m1, tmat2x2<T, P> const & m2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<2, 2, T, P> operator*(mat<2, 2, T, P> const & m1, mat<2, 2, T, P> const & m2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat3x2<T, P> operator*(tmat2x2<T, P> const & m1, tmat3x2<T, P> const & m2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<3, 2, T, P> operator*(mat<2, 2, T, P> const & m1, mat<3, 2, T, P> const & m2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat4x2<T, P> operator*(tmat2x2<T, P> const & m1, tmat4x2<T, P> const & m2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<4, 2, T, P> operator*(mat<2, 2, T, P> const & m1, mat<4, 2, T, P> const & m2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x2<T, P> operator/(tmat2x2<T, P> const & m, T scalar);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<2, 2, T, P> operator/(mat<2, 2, T, P> const & m, T scalar);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x2<T, P> operator/(T scalar, tmat2x2<T, P> const & m);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<2, 2, T, P> operator/(T scalar, mat<2, 2, T, P> const & m);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL typename tmat2x2<T, P>::col_type operator/(tmat2x2<T, P> const & m, typename tmat2x2<T, P>::row_type const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL typename mat<2, 2, T, P>::col_type operator/(mat<2, 2, T, P> const & m, typename mat<2, 2, T, P>::row_type const & v);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL typename tmat2x2<T, P>::row_type operator/(typename tmat2x2<T, P>::col_type const & v, tmat2x2<T, P> const & m);
+	template<typename T, precision P>
+	GLM_FUNC_DECL typename mat<2, 2, T, P>::row_type operator/(typename mat<2, 2, T, P>::col_type const & v, mat<2, 2, T, P> const & m);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x2<T, P> operator/(tmat2x2<T, P> const & m1, tmat2x2<T, P> const & m2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<2, 2, T, P> operator/(mat<2, 2, T, P> const & m1, mat<2, 2, T, P> const & m2);
 
 	// -- Boolean operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL bool operator==(tmat2x2<T, P> const & m1, tmat2x2<T, P> const & m2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL bool operator==(mat<2, 2, T, P> const & m1, mat<2, 2, T, P> const & m2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL bool operator!=(tmat2x2<T, P> const & m1, tmat2x2<T, P> const & m2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL bool operator!=(mat<2, 2, T, P> const & m1, mat<2, 2, T, P> const & m2);
 } //namespace glm
 
 #ifndef GLM_EXTERNAL_TEMPLATE
diff --git a/glm/detail/type_mat2x2.inl b/glm/detail/type_mat2x2.inl
index 02c5ee8b..cfd7a868 100644
--- a/glm/detail/type_mat2x2.inl
+++ b/glm/detail/type_mat2x2.inl
@@ -8,8 +8,8 @@ namespace glm
 	// -- Constructors --
 
 #	if !GLM_HAS_DEFAULTED_FUNCTIONS || !defined(GLM_FORCE_NO_CTOR_INIT)
-		template <typename T, precision P>
-		GLM_FUNC_QUALIFIER tmat2x2<T, P>::tmat2x2()
+		template<typename T, precision P>
+		GLM_FUNC_QUALIFIER mat<2, 2, T, P>::mat()
 		{
 #			ifndef GLM_FORCE_NO_CTOR_INIT 
 				this->value[0] = col_type(1, 0);
@@ -19,35 +19,35 @@ namespace glm
 #	endif
 
 #	if !GLM_HAS_DEFAULTED_FUNCTIONS
-		template <typename T, precision P>
-		GLM_FUNC_QUALIFIER tmat2x2<T, P>::tmat2x2(tmat2x2<T, P> const & m)
+		template<typename T, precision P>
+		GLM_FUNC_QUALIFIER mat<2, 2, T, P>::mat(mat<2, 2, T, P> const& m)
 		{
 			this->value[0] = m.value[0];
 			this->value[1] = m.value[1];
 		}
 #	endif//!GLM_HAS_DEFAULTED_FUNCTIONS
 
-	template <typename T, precision P>
-	template <precision Q>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>::tmat2x2(tmat2x2<T, Q> const & m)
+	template<typename T, precision P>
+	template<precision Q>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, P>::mat(mat<2, 2, T, Q> const& m)
 	{
 		this->value[0] = m.value[0];
 		this->value[1] = m.value[1];
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR tmat2x2<T, P>::tmat2x2(ctor)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR mat<2, 2, T, P>::mat(ctor)
 	{}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>::tmat2x2(T scalar)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, P>::mat(T scalar)
 	{
 		this->value[0] = col_type(scalar, 0);
 		this->value[1] = col_type(0, scalar);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>::tmat2x2
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, P>::mat 
 	(
 		T const & x0, T const & y0,
 		T const & x1, T const & y1
@@ -57,8 +57,8 @@ namespace glm
 		this->value[1] = col_type(x1, y1);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>::tmat2x2(col_type const & v0, col_type const & v1)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, P>::mat(col_type const& v0, col_type const& v1)
 	{
 		this->value[0] = v0;
 		this->value[1] = v1;
@@ -66,9 +66,9 @@ namespace glm
 
 	// -- Conversion constructors --
 
-	template <typename T, precision P>
-	template <typename X1, typename Y1, typename X2, typename Y2>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>::tmat2x2
+	template<typename T, precision P>
+	template<typename X1, typename Y1, typename X2, typename Y2>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, P>::mat 
 	(
 		X1 const & x1, Y1 const & y1,
 		X2 const & x2, Y2 const & y2
@@ -78,9 +78,9 @@ namespace glm
 		this->value[1] = col_type(static_cast<T>(x2), value_type(y2));
 	}
 	
-	template <typename T, precision P>
-	template <typename V1, typename V2>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>::tmat2x2(tvec2<V1, P> const & v1, tvec2<V2, P> const & v2)
+	template<typename T, precision P>
+	template<typename V1, typename V2>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, P>::mat(vec<2, V1, P> const& v1, vec<2, V2, P> const& v2)
 	{
 		this->value[0] = col_type(v1);
 		this->value[1] = col_type(v2);
@@ -88,65 +88,65 @@ namespace glm
 
 	// -- mat2x2 matrix conversions --
 
-	template <typename T, precision P>
-	template <typename U, precision Q>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>::tmat2x2(tmat2x2<U, Q> const & m)
+	template<typename T, precision P>
+	template<typename U, precision Q>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, P>::mat(mat<2, 2, U, Q> const& m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>::tmat2x2(tmat3x3<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, P>::mat(mat<3, 3, T, P> const& m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>::tmat2x2(tmat4x4<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, P>::mat(mat<4, 4, T, P> const& m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>::tmat2x2(tmat2x3<T, P> const & m)
+	template<typename T, precision P> 
+	GLM_FUNC_QUALIFIER mat<2, 2, T, P>::mat(mat<2, 3, T, P> const& m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>::tmat2x2(tmat3x2<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, P>::mat(mat<3, 2, T, P> const& m)
 	{
 		this->value[0] = m[0];
 		this->value[1] = m[1];
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>::tmat2x2(tmat2x4<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, P>::mat(mat<2, 4, T, P> const& m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>::tmat2x2(tmat4x2<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, P>::mat(mat<4, 2, T, P> const& m)
 	{
 		this->value[0] = m[0];
 		this->value[1] = m[1];
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>::tmat2x2(tmat3x4<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, P>::mat(mat<3, 4, T, P> const& m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>::tmat2x2(tmat4x3<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, P>::mat(mat<4, 3, T, P> const& m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
@@ -154,15 +154,15 @@ namespace glm
 
 	// -- Accesses --
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER typename tmat2x2<T, P>::col_type & tmat2x2<T, P>::operator[](typename tmat2x2<T, P>::length_type i)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER typename mat<2, 2, T, P>::col_type& mat<2, 2, T, P>::operator[](typename mat<2, 2, T, P>::length_type i)
 	{
 		assert(i < this->length());
 		return this->value[i];
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER typename tmat2x2<T, P>::col_type const & tmat2x2<T, P>::operator[](typename tmat2x2<T, P>::length_type i) const
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER typename mat<2, 2, T, P>::col_type const& mat<2, 2, T, P>::operator[](typename mat<2, 2, T, P>::length_type i) const
 	{
 		assert(i < this->length());
 		return this->value[i];
@@ -171,8 +171,8 @@ namespace glm
 	// -- Unary updatable operators --
 
 #	if !GLM_HAS_DEFAULTED_FUNCTIONS
-		template <typename T, precision P>
-		GLM_FUNC_QUALIFIER tmat2x2<T, P>& tmat2x2<T, P>::operator=(tmat2x2<T, P> const & m)
+		template<typename T, precision P>
+		GLM_FUNC_QUALIFIER mat<2, 2, T, P>& mat<2, 2, T, P>::operator=(mat<2, 2, T, P> const & m)
 		{
 			this->value[0] = m[0];
 			this->value[1] = m[1];
@@ -180,237 +180,237 @@ namespace glm
 		}
 #	endif//!GLM_HAS_DEFAULTED_FUNCTIONS
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>& tmat2x2<T, P>::operator=(tmat2x2<U, P> const & m)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, P>& mat<2, 2, T, P>::operator=(mat<2, 2, U, P> const & m)
 	{
 		this->value[0] = m[0];
 		this->value[1] = m[1];
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>& tmat2x2<T, P>::operator+=(U scalar)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, P>& mat<2, 2, T, P>::operator+=(U scalar)
 	{
 		this->value[0] += scalar;
 		this->value[1] += scalar;
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>& tmat2x2<T, P>::operator+=(tmat2x2<U, P> const & m)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, P>& mat<2, 2, T, P>::operator+=(mat<2, 2, U, P> const & m)
 	{
 		this->value[0] += m[0];
 		this->value[1] += m[1];
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>& tmat2x2<T, P>::operator-=(U scalar)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, P>& mat<2, 2, T, P>::operator-=(U scalar)
 	{
 		this->value[0] -= scalar;
 		this->value[1] -= scalar;
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>& tmat2x2<T, P>::operator-=(tmat2x2<U, P> const & m)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, P>& mat<2, 2, T, P>::operator-=(mat<2, 2, U, P> const & m)
 	{
 		this->value[0] -= m[0];
 		this->value[1] -= m[1];
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>& tmat2x2<T, P>::operator*=(U scalar)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, P>& mat<2, 2, T, P>::operator*=(U scalar)
 	{
 		this->value[0] *= scalar;
 		this->value[1] *= scalar;
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>& tmat2x2<T, P>::operator*=(tmat2x2<U, P> const & m)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, P>& mat<2, 2, T, P>::operator*=(mat<2, 2, U, P> const & m)
 	{
 		return (*this = *this * m);
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>& tmat2x2<T, P>::operator/=(U scalar)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, P>& mat<2, 2, T, P>::operator/=(U scalar)
 	{
 		this->value[0] /= scalar;
 		this->value[1] /= scalar;
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>& tmat2x2<T, P>::operator/=(tmat2x2<U, P> const & m)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, P>& mat<2, 2, T, P>::operator/=(mat<2, 2, U, P> const & m)
 	{
 		return *this *= inverse(m);
 	}
 
 	// -- Increment and decrement operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>& tmat2x2<T, P>::operator++()
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, P>& mat<2, 2, T, P>::operator++()
 	{
 		++this->value[0];
 		++this->value[1];
 		return *this;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>& tmat2x2<T, P>::operator--()
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, P>& mat<2, 2, T, P>::operator--()
 	{
 		--this->value[0];
 		--this->value[1];
 		return *this;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P> tmat2x2<T, P>::operator++(int)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, P> mat<2, 2, T, P>::operator++(int)
 	{
-		tmat2x2<T, P> Result(*this);
+		mat<2, 2, T, P> Result(*this);
 		++*this;
 		return Result;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P> tmat2x2<T, P>::operator--(int)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, P> mat<2, 2, T, P>::operator--(int)
 	{
-		tmat2x2<T, P> Result(*this);
+		mat<2, 2, T, P> Result(*this);
 		--*this;
 		return Result;
 	}
 
 	// -- Unary arithmetic operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P> operator+(tmat2x2<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, P> operator+(mat<2, 2, T, P> const & m)
 	{
 		return m;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P> operator-(tmat2x2<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, P> operator-(mat<2, 2, T, P> const & m)
 	{
-		return tmat2x2<T, P>(
+		return mat<2, 2, T, P>(
 			-m[0], 
 			-m[1]);
 	}
 
 	// -- Binary arithmetic operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P> operator+(tmat2x2<T, P> const & m, T scalar)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, P> operator+(mat<2, 2, T, P> const & m, T scalar)
 	{
-		return tmat2x2<T, P>(
+		return mat<2, 2, T, P>(
 			m[0] + scalar,
 			m[1] + scalar);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P> operator+(T scalar, tmat2x2<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, P> operator+(T scalar, mat<2, 2, T, P> const & m)
 	{
-		return tmat2x2<T, P>(
+		return mat<2, 2, T, P>(
 			m[0] + scalar,
 			m[1] + scalar);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P> operator+(tmat2x2<T, P> const & m1, tmat2x2<T, P> const & m2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, P> operator+(mat<2, 2, T, P> const & m1, mat<2, 2, T, P> const & m2)
 	{
-		return tmat2x2<T, P>(
+		return mat<2, 2, T, P>(
 			m1[0] + m2[0],
 			m1[1] + m2[1]);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P> operator-(tmat2x2<T, P> const & m, T scalar)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, P> operator-(mat<2, 2, T, P> const & m, T scalar)
 	{
-		return tmat2x2<T, P>(
+		return mat<2, 2, T, P>(
 			m[0] - scalar,
 			m[1] - scalar);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P> operator-(T scalar, tmat2x2<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, P> operator-(T scalar, mat<2, 2, T, P> const & m)
 	{
-		return tmat2x2<T, P>(
+		return mat<2, 2, T, P>(
 			scalar - m[0],
 			scalar - m[1]);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P> operator-(tmat2x2<T, P> const & m1, tmat2x2<T, P> const & m2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, P> operator-(mat<2, 2, T, P> const & m1, mat<2, 2, T, P> const & m2)
 	{
-		return tmat2x2<T, P>(
+		return mat<2, 2, T, P>(
 			m1[0] - m2[0],
 			m1[1] - m2[1]);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P> operator*(tmat2x2<T, P> const & m, T scalar)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, P> operator*(mat<2, 2, T, P> const & m, T scalar)
 	{
-		return tmat2x2<T, P>(
+		return mat<2, 2, T, P>(
 			m[0] * scalar,
 			m[1] * scalar);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P> operator*(T scalar, tmat2x2<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, P> operator*(T scalar, mat<2, 2, T, P> const & m)
 	{
-		return tmat2x2<T, P>(
+		return mat<2, 2, T, P>(
 			m[0] * scalar,
 			m[1] * scalar);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER typename tmat2x2<T, P>::col_type operator*
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER typename mat<2, 2, T, P>::col_type operator*
 	(
-		tmat2x2<T, P> const & m,
-		typename tmat2x2<T, P>::row_type const & v
+		mat<2, 2, T, P> const& m,
+		typename mat<2, 2, T, P>::row_type const & v
 	)
 	{
-		return tvec2<T, P>(
+		return vec<2, T, P>(
 			m[0][0] * v.x + m[1][0] * v.y,
 			m[0][1] * v.x + m[1][1] * v.y);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER typename tmat2x2<T, P>::row_type operator*
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER typename mat<2, 2, T, P>::row_type operator*
 	(
-		typename tmat2x2<T, P>::col_type const & v,
-		tmat2x2<T, P> const & m
+		typename mat<2, 2, T, P>::col_type const & v,
+		mat<2, 2, T, P> const& m
 	)
 	{
-		return tvec2<T, P>(
+		return vec<2, T, P>(
 			v.x * m[0][0] + v.y * m[0][1],
 			v.x * m[1][0] + v.y * m[1][1]);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P> operator*(tmat2x2<T, P> const & m1, tmat2x2<T, P> const & m2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, P> operator*(mat<2, 2, T, P> const & m1, mat<2, 2, T, P> const & m2)
 	{
-		return tmat2x2<T, P>(
+		return mat<2, 2, T, P>(
 			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1],
 			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1],
 			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1],
 			m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1]);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x2<T, P> operator*(tmat2x2<T, P> const & m1, tmat3x2<T, P> const & m2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, P> operator*(mat<2, 2, T, P> const & m1, mat<3, 2, T, P> const & m2)
 	{
-		return tmat3x2<T, P>(
+		return mat<3, 2, T, P>(
 			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1],
 			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1],
 			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1],
@@ -419,10 +419,10 @@ namespace glm
 			m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1]);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x2<T, P> operator*(tmat2x2<T, P> const & m1, tmat4x2<T, P> const & m2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, P> operator*(mat<2, 2, T, P> const & m1, mat<4, 2, T, P> const & m2)
 	{
-		return tmat4x2<T, P>(
+		return mat<4, 2, T, P>(
 			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1],
 			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1],
 			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1],
@@ -433,51 +433,51 @@ namespace glm
 			m1[0][1] * m2[3][0] + m1[1][1] * m2[3][1]);
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat2x2<T, P> operator/(tmat2x2<T, P> const & m, T scalar)
+	template<typename T, precision P> 
+	GLM_FUNC_QUALIFIER mat<2, 2, T, P> operator/(mat<2, 2, T, P> const & m, T scalar)
 	{
-		return tmat2x2<T, P>(
+		return mat<2, 2, T, P>(
 			m[0] / scalar,
 			m[1] / scalar);
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat2x2<T, P> operator/(T scalar, tmat2x2<T, P> const & m)
+	template<typename T, precision P> 
+	GLM_FUNC_QUALIFIER mat<2, 2, T, P> operator/(T scalar, mat<2, 2, T, P> const & m)
 	{
-		return tmat2x2<T, P>(
+		return mat<2, 2, T, P>(
 			scalar / m[0],
 			scalar / m[1]);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER typename tmat2x2<T, P>::col_type operator/(tmat2x2<T, P> const & m, typename tmat2x2<T, P>::row_type const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER typename mat<2, 2, T, P>::col_type operator/(mat<2, 2, T, P> const & m, typename mat<2, 2, T, P>::row_type const & v)
 	{
 		return inverse(m) * v;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER typename tmat2x2<T, P>::row_type operator/(typename tmat2x2<T, P>::col_type const & v, tmat2x2<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER typename mat<2, 2, T, P>::row_type operator/(typename mat<2, 2, T, P>::col_type const & v, mat<2, 2, T, P> const & m)
 	{
 		return v *  inverse(m);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P> operator/(tmat2x2<T, P> const & m1, tmat2x2<T, P> const & m2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, P> operator/(mat<2, 2, T, P> const & m1, mat<2, 2, T, P> const & m2)
 	{	
-		tmat2x2<T, P> m1_copy(m1);
+		mat<2, 2, T, P> m1_copy(m1);
 		return m1_copy /= m2;
 	}
 
 	// -- Boolean operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER bool operator==(tmat2x2<T, P> const & m1, tmat2x2<T, P> const & m2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER bool operator==(mat<2, 2, T, P> const & m1, mat<2, 2, T, P> const & m2)
 	{
 		return (m1[0] == m2[0]) && (m1[1] == m2[1]);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER bool operator!=(tmat2x2<T, P> const & m1, tmat2x2<T, P> const & m2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER bool operator!=(mat<2, 2, T, P> const & m1, mat<2, 2, T, P> const & m2)
 	{
 		return (m1[0] != m2[0]) || (m1[1] != m2[1]);
 	}
diff --git a/glm/detail/type_mat2x3.hpp b/glm/detail/type_mat2x3.hpp
index db558863..01eb777a 100644
--- a/glm/detail/type_mat2x3.hpp
+++ b/glm/detail/type_mat2x3.hpp
@@ -12,13 +12,13 @@
 
 namespace glm
 {
-	template <typename T, precision P = defaultp>
-	struct tmat2x3
+	template<typename T, precision P>
+	struct mat<2, 3, T, P>
 	{
-		typedef tvec3<T, P> col_type;
-		typedef tvec2<T, P> row_type;
-		typedef tmat2x3<T, P> type;
-		typedef tmat3x2<T, P> transpose_type;
+		typedef vec<3, T, P> col_type;
+		typedef vec<2, T, P> row_type;
+		typedef mat<2, 3, T, P> type;
+		typedef mat<3, 2, T, P> transpose_type;
 		typedef T value_type;
 
 	private:
@@ -27,45 +27,45 @@ namespace glm
 	public:
 		// -- Constructors --
 
-		GLM_FUNC_DECL tmat2x3() GLM_DEFAULT_CTOR;
-		GLM_FUNC_DECL tmat2x3(tmat2x3<T, P> const & m) GLM_DEFAULT;
-		template <precision Q>
-		GLM_FUNC_DECL tmat2x3(tmat2x3<T, Q> const & m);
+		GLM_FUNC_DECL mat() GLM_DEFAULT_CTOR;
+		GLM_FUNC_DECL mat(mat<2, 3, T, P> const & m) GLM_DEFAULT;
+		template<precision Q>
+		GLM_FUNC_DECL mat(mat<2, 3, T, Q> const & m);
 
-		GLM_FUNC_DECL GLM_CONSTEXPR_CTOR explicit tmat2x3(ctor);
-		GLM_FUNC_DECL explicit tmat2x3(T scalar);
-		GLM_FUNC_DECL tmat2x3(
+		GLM_FUNC_DECL GLM_CONSTEXPR_CTOR explicit mat(ctor);
+		GLM_FUNC_DECL explicit mat(T scalar);
+		GLM_FUNC_DECL mat(
 			T x0, T y0, T z0,
 			T x1, T y1, T z1);
-		GLM_FUNC_DECL tmat2x3(
+		GLM_FUNC_DECL mat(
 			col_type const & v0,
 			col_type const & v1);
 
 		// -- Conversions --
 
-		template <typename X1, typename Y1, typename Z1, typename X2, typename Y2, typename Z2>
-		GLM_FUNC_DECL tmat2x3(
+		template<typename X1, typename Y1, typename Z1, typename X2, typename Y2, typename Z2>
+		GLM_FUNC_DECL mat(
 			X1 x1, Y1 y1, Z1 z1,
 			X2 x2, Y2 y2, Z2 z2);
 
-		template <typename U, typename V>
-		GLM_FUNC_DECL tmat2x3(
-			tvec3<U, P> const & v1,
-			tvec3<V, P> const & v2);
+		template<typename U, typename V>
+		GLM_FUNC_DECL mat(
+			vec<3, U, P> const & v1,
+			vec<3, V, P> const & v2);
 
 		// -- Matrix conversions --
 
-		template <typename U, precision Q>
-		GLM_FUNC_DECL GLM_EXPLICIT tmat2x3(tmat2x3<U, Q> const & m);
+		template<typename U, precision Q>
+		GLM_FUNC_DECL GLM_EXPLICIT mat(mat<2, 3, U, Q> const & m);
 
-		GLM_FUNC_DECL GLM_EXPLICIT tmat2x3(tmat2x2<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat2x3(tmat3x3<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat2x3(tmat4x4<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat2x3(tmat2x4<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat2x3(tmat3x2<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat2x3(tmat3x4<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat2x3(tmat4x2<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat2x3(tmat4x3<T, P> const & x);
+		GLM_FUNC_DECL GLM_EXPLICIT mat(mat<2, 2, T, P> const & x);
+		GLM_FUNC_DECL GLM_EXPLICIT mat(mat<3, 3, T, P> const & x);
+		GLM_FUNC_DECL GLM_EXPLICIT mat(mat<4, 4, T, P> const & x);
+		GLM_FUNC_DECL GLM_EXPLICIT mat(mat<2, 4, T, P> const & x);
+		GLM_FUNC_DECL GLM_EXPLICIT mat(mat<3, 2, T, P> const & x);
+		GLM_FUNC_DECL GLM_EXPLICIT mat(mat<3, 4, T, P> const & x);
+		GLM_FUNC_DECL GLM_EXPLICIT mat(mat<4, 2, T, P> const & x);
+		GLM_FUNC_DECL GLM_EXPLICIT mat(mat<4, 3, T, P> const & x);
 
 		// -- Accesses --
 
@@ -77,87 +77,87 @@ namespace glm
 
 		// -- Unary arithmetic operators --
 
-		GLM_FUNC_DECL tmat2x3<T, P> & operator=(tmat2x3<T, P> const & m) GLM_DEFAULT;
+		GLM_FUNC_DECL mat<2, 3, T, P> & operator=(mat<2, 3, T, P> const & m) GLM_DEFAULT;
 
-		template <typename U>
-		GLM_FUNC_DECL tmat2x3<T, P> & operator=(tmat2x3<U, P> const & m);
-		template <typename U>
-		GLM_FUNC_DECL tmat2x3<T, P> & operator+=(U s);
-		template <typename U>
-		GLM_FUNC_DECL tmat2x3<T, P> & operator+=(tmat2x3<U, P> const & m);
-		template <typename U>
-		GLM_FUNC_DECL tmat2x3<T, P> & operator-=(U s);
-		template <typename U>
-		GLM_FUNC_DECL tmat2x3<T, P> & operator-=(tmat2x3<U, P> const & m);
-		template <typename U>
-		GLM_FUNC_DECL tmat2x3<T, P> & operator*=(U s);
-		template <typename U>
-		GLM_FUNC_DECL tmat2x3<T, P> & operator/=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<2, 3, T, P> & operator=(mat<2, 3, U, P> const & m);
+		template<typename U>
+		GLM_FUNC_DECL mat<2, 3, T, P> & operator+=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<2, 3, T, P> & operator+=(mat<2, 3, U, P> const & m);
+		template<typename U>
+		GLM_FUNC_DECL mat<2, 3, T, P> & operator-=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<2, 3, T, P> & operator-=(mat<2, 3, U, P> const & m);
+		template<typename U>
+		GLM_FUNC_DECL mat<2, 3, T, P> & operator*=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<2, 3, T, P> & operator/=(U s);
 
 		// -- Increment and decrement operators --
 
-		GLM_FUNC_DECL tmat2x3<T, P> & operator++ ();
-		GLM_FUNC_DECL tmat2x3<T, P> & operator-- ();
-		GLM_FUNC_DECL tmat2x3<T, P> operator++(int);
-		GLM_FUNC_DECL tmat2x3<T, P> operator--(int);
+		GLM_FUNC_DECL mat<2, 3, T, P> & operator++ ();
+		GLM_FUNC_DECL mat<2, 3, T, P> & operator-- ();
+		GLM_FUNC_DECL mat<2, 3, T, P> operator++(int);
+		GLM_FUNC_DECL mat<2, 3, T, P> operator--(int);
 	};
 
 	// -- Unary operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x3<T, P> operator+(tmat2x3<T, P> const & m);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<2, 3, T, P> operator+(mat<2, 3, T, P> const & m);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x3<T, P> operator-(tmat2x3<T, P> const & m);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<2, 3, T, P> operator-(mat<2, 3, T, P> const & m);
 
 	// -- Binary operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x3<T, P> operator+(tmat2x3<T, P> const & m, T scalar);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<2, 3, T, P> operator+(mat<2, 3, T, P> const & m, T scalar);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x3<T, P> operator+(tmat2x3<T, P> const & m1, tmat2x3<T, P> const & m2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<2, 3, T, P> operator+(mat<2, 3, T, P> const & m1, mat<2, 3, T, P> const & m2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x3<T, P> operator-(tmat2x3<T, P> const & m, T scalar);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<2, 3, T, P> operator-(mat<2, 3, T, P> const & m, T scalar);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x3<T, P> operator-(tmat2x3<T, P> const & m1, tmat2x3<T, P> const & m2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<2, 3, T, P> operator-(mat<2, 3, T, P> const & m1, mat<2, 3, T, P> const & m2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x3<T, P> operator*(tmat2x3<T, P> const & m, T scalar);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<2, 3, T, P> operator*(mat<2, 3, T, P> const & m, T scalar);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x3<T, P> operator*(T scalar, tmat2x3<T, P> const & m);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<2, 3, T, P> operator*(T scalar, mat<2, 3, T, P> const & m);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL typename tmat2x3<T, P>::col_type operator*(tmat2x3<T, P> const & m, typename tmat2x3<T, P>::row_type const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL typename mat<2, 3, T, P>::col_type operator*(mat<2, 3, T, P> const & m, typename mat<2, 3, T, P>::row_type const & v);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL typename tmat2x3<T, P>::row_type operator*(typename tmat2x3<T, P>::col_type const & v, tmat2x3<T, P> const & m);
+	template<typename T, precision P>
+	GLM_FUNC_DECL typename mat<2, 3, T, P>::row_type operator*(typename mat<2, 3, T, P>::col_type const & v, mat<2, 3, T, P> const & m);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x3<T, P> operator*(tmat2x3<T, P> const & m1, tmat2x2<T, P> const & m2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<2, 3, T, P> operator*(mat<2, 3, T, P> const & m1, mat<2, 2, T, P> const & m2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat3x3<T, P> operator*(tmat2x3<T, P> const & m1, tmat3x2<T, P> const & m2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<3, 3, T, P> operator*(mat<2, 3, T, P> const & m1, mat<3, 2, T, P> const & m2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat4x3<T, P> operator*(tmat2x3<T, P> const & m1, tmat4x2<T, P> const & m2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<4, 3, T, P> operator*(mat<2, 3, T, P> const & m1, mat<4, 2, T, P> const & m2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x3<T, P> operator/(tmat2x3<T, P> const & m, T scalar);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<2, 3, T, P> operator/(mat<2, 3, T, P> const & m, T scalar);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x3<T, P> operator/(T scalar, tmat2x3<T, P> const & m);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<2, 3, T, P> operator/(T scalar, mat<2, 3, T, P> const & m);
 
 	// -- Boolean operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL bool operator==(tmat2x3<T, P> const & m1, tmat2x3<T, P> const & m2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL bool operator==(mat<2, 3, T, P> const & m1, mat<2, 3, T, P> const & m2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL bool operator!=(tmat2x3<T, P> const & m1, tmat2x3<T, P> const & m2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL bool operator!=(mat<2, 3, T, P> const & m1, mat<2, 3, T, P> const & m2);
 }//namespace glm
 
 #ifndef GLM_EXTERNAL_TEMPLATE
diff --git a/glm/detail/type_mat2x3.inl b/glm/detail/type_mat2x3.inl
index b0f8337c..e18ab386 100644
--- a/glm/detail/type_mat2x3.inl
+++ b/glm/detail/type_mat2x3.inl
@@ -6,8 +6,8 @@ namespace glm
 	// -- Constructors --
 
 #	if !GLM_HAS_DEFAULTED_FUNCTIONS || !defined(GLM_FORCE_NO_CTOR_INIT)
-		template <typename T, precision P> 
-		GLM_FUNC_QUALIFIER tmat2x3<T, P>::tmat2x3()
+		template<typename T, precision P> 
+		GLM_FUNC_QUALIFIER mat<2, 3, T, P>::mat()
 		{
 #			ifndef GLM_FORCE_NO_CTOR_INIT 
 				this->value[0] = col_type(1, 0, 0);
@@ -17,35 +17,35 @@ namespace glm
 #	endif
 
 #	if !GLM_HAS_DEFAULTED_FUNCTIONS
-		template <typename T, precision P>
-		GLM_FUNC_QUALIFIER tmat2x3<T, P>::tmat2x3(tmat2x3<T, P> const & m)
+		template<typename T, precision P>
+		GLM_FUNC_QUALIFIER mat<2, 3, T, P>::mat(mat<2, 3, T, P> const & m)
 		{
 			this->value[0] = m.value[0];
 			this->value[1] = m.value[1];
 		}
 #	endif//!GLM_HAS_DEFAULTED_FUNCTIONS
 
-	template <typename T, precision P>
-	template <precision Q>
-	GLM_FUNC_QUALIFIER tmat2x3<T, P>::tmat2x3(tmat2x3<T, Q> const & m)
+	template<typename T, precision P>
+	template<precision Q>
+	GLM_FUNC_QUALIFIER mat<2, 3, T, P>::mat(mat<2, 3, T, Q> const & m)
 	{
 		this->value[0] = m.value[0];
 		this->value[1] = m.value[1];
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR tmat2x3<T, P>::tmat2x3(ctor)
+	template<typename T, precision P> 
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR mat<2, 3, T, P>::mat(ctor)
 	{}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat2x3<T, P>::tmat2x3(T scalar)
+	template<typename T, precision P> 
+	GLM_FUNC_QUALIFIER mat<2, 3, T, P>::mat(T scalar)
 	{
 		this->value[0] = col_type(scalar, 0, 0);
 		this->value[1] = col_type(0, scalar, 0);
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat2x3<T, P>::tmat2x3
+	template<typename T, precision P> 
+	GLM_FUNC_QUALIFIER mat<2, 3, T, P>::mat 
 	(
 		T x0, T y0, T z0,
 		T x1, T y1, T z1
@@ -55,8 +55,8 @@ namespace glm
 		this->value[1] = col_type(x1, y1, z1);
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat2x3<T, P>::tmat2x3(col_type const & v0, col_type const & v1)
+	template<typename T, precision P> 
+	GLM_FUNC_QUALIFIER mat<2, 3, T, P>::mat(col_type const & v0, col_type const & v1)
 	{
 		this->value[0] = v0;
 		this->value[1] = v1;
@@ -64,11 +64,11 @@ namespace glm
 
 	// -- Conversion constructors --
 
-	template <typename T, precision P>
-	template <
+	template<typename T, precision P>
+	template<
 		typename X1, typename Y1, typename Z1,
 		typename X2, typename Y2, typename Z2>
-	GLM_FUNC_QUALIFIER tmat2x3<T, P>::tmat2x3
+	GLM_FUNC_QUALIFIER mat<2, 3, T, P>::mat 
 	(
 		X1 x1, Y1 y1, Z1 z1,
 		X2 x2, Y2 y2, Z2 z2
@@ -78,9 +78,9 @@ namespace glm
 		this->value[1] = col_type(static_cast<T>(x2), value_type(y2), value_type(z2));
 	}
 	
-	template <typename T, precision P>
-	template <typename V1, typename V2>
-	GLM_FUNC_QUALIFIER tmat2x3<T, P>::tmat2x3(tvec3<V1, P> const & v1, tvec3<V2, P> const & v2)
+	template<typename T, precision P>
+	template<typename V1, typename V2>
+	GLM_FUNC_QUALIFIER mat<2, 3, T, P>::mat(vec<3, V1, P> const & v1, vec<3, V2, P> const & v2)
 	{
 		this->value[0] = col_type(v1);
 		this->value[1] = col_type(v2);
@@ -88,65 +88,65 @@ namespace glm
 
 	// -- Matrix conversions --
 
-	template <typename T, precision P>
-	template <typename U, precision Q>
-	GLM_FUNC_QUALIFIER tmat2x3<T, P>::tmat2x3(tmat2x3<U, Q> const & m)
+	template<typename T, precision P>
+	template<typename U, precision Q>
+	GLM_FUNC_QUALIFIER mat<2, 3, T, P>::mat(mat<2, 3, U, Q> const & m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat2x3<T, P>::tmat2x3(tmat2x2<T, P> const & m)
+	template<typename T, precision P> 
+	GLM_FUNC_QUALIFIER mat<2, 3, T, P>::mat(mat<2, 2, T, P> const & m)
 	{
 		this->value[0] = col_type(m[0], 0);
 		this->value[1] = col_type(m[1], 0);
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER  tmat2x3<T, P>::tmat2x3(tmat3x3<T, P> const & m)
+	template<typename T, precision P> 
+	GLM_FUNC_QUALIFIER  mat<2, 3, T, P>::mat(mat<3, 3, T, P> const & m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat2x3<T, P>::tmat2x3(tmat4x4<T, P> const & m)
+	template<typename T, precision P> 
+	GLM_FUNC_QUALIFIER mat<2, 3, T, P>::mat(mat<4, 4, T, P> const & m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat2x3<T, P>::tmat2x3(tmat2x4<T, P> const & m)
+	template<typename T, precision P> 
+	GLM_FUNC_QUALIFIER mat<2, 3, T, P>::mat(mat<2, 4, T, P> const & m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat2x3<T, P>::tmat2x3(tmat3x2<T, P> const & m)
+	template<typename T, precision P> 
+	GLM_FUNC_QUALIFIER mat<2, 3, T, P>::mat(mat<3, 2, T, P> const & m)
 	{
 		this->value[0] = col_type(m[0], 0);
 		this->value[1] = col_type(m[1], 0);
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat2x3<T, P>::tmat2x3(tmat3x4<T, P> const & m)
+	template<typename T, precision P> 
+	GLM_FUNC_QUALIFIER mat<2, 3, T, P>::mat(mat<3, 4, T, P> const & m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat2x3<T, P>::tmat2x3(tmat4x2<T, P> const & m)
+	template<typename T, precision P> 
+	GLM_FUNC_QUALIFIER mat<2, 3, T, P>::mat(mat<4, 2, T, P> const & m)
 	{
 		this->value[0] = col_type(m[0], 0);
 		this->value[1] = col_type(m[1], 0);
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat2x3<T, P>::tmat2x3(tmat4x3<T, P> const & m)
+	template<typename T, precision P> 
+	GLM_FUNC_QUALIFIER mat<2, 3, T, P>::mat(mat<4, 3, T, P> const & m)
 	{
 		this->value[0] = m[0];
 		this->value[1] = m[1];
@@ -154,15 +154,15 @@ namespace glm
 
 	// -- Accesses --
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER typename tmat2x3<T, P>::col_type & tmat2x3<T, P>::operator[](typename tmat2x3<T, P>::length_type i)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER typename mat<2, 3, T, P>::col_type & mat<2, 3, T, P>::operator[](typename mat<2, 3, T, P>::length_type i)
 	{
 		assert(i < this->length());
 		return this->value[i];
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER typename tmat2x3<T, P>::col_type const & tmat2x3<T, P>::operator[](typename tmat2x3<T, P>::length_type i) const
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER typename mat<2, 3, T, P>::col_type const & mat<2, 3, T, P>::operator[](typename mat<2, 3, T, P>::length_type i) const
 	{
 		assert(i < this->length());
 		return this->value[i];
@@ -171,8 +171,8 @@ namespace glm
 	// -- Unary updatable operators --
 
 #	if !GLM_HAS_DEFAULTED_FUNCTIONS
-		template <typename T, precision P>
-		GLM_FUNC_QUALIFIER tmat2x3<T, P>& tmat2x3<T, P>::operator=(tmat2x3<T, P> const & m)
+		template<typename T, precision P>
+		GLM_FUNC_QUALIFIER mat<2, 3, T, P>& mat<2, 3, T, P>::operator=(mat<2, 3, T, P> const & m)
 		{
 			this->value[0] = m[0];
 			this->value[1] = m[1];
@@ -180,63 +180,63 @@ namespace glm
 		}
 #	endif//!GLM_HAS_DEFAULTED_FUNCTIONS
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat2x3<T, P>& tmat2x3<T, P>::operator=(tmat2x3<U, P> const & m)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<2, 3, T, P>& mat<2, 3, T, P>::operator=(mat<2, 3, U, P> const & m)
 	{
 		this->value[0] = m[0];
 		this->value[1] = m[1];
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat2x3<T, P> & tmat2x3<T, P>::operator+=(U s)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<2, 3, T, P> & mat<2, 3, T, P>::operator+=(U s)
 	{
 		this->value[0] += s;
 		this->value[1] += s;
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat2x3<T, P>& tmat2x3<T, P>::operator+=(tmat2x3<U, P> const & m)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<2, 3, T, P>& mat<2, 3, T, P>::operator+=(mat<2, 3, U, P> const & m)
 	{
 		this->value[0] += m[0];
 		this->value[1] += m[1];
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat2x3<T, P>& tmat2x3<T, P>::operator-=(U s)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<2, 3, T, P>& mat<2, 3, T, P>::operator-=(U s)
 	{
 		this->value[0] -= s;
 		this->value[1] -= s;
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat2x3<T, P>& tmat2x3<T, P>::operator-=(tmat2x3<U, P> const & m)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<2, 3, T, P>& mat<2, 3, T, P>::operator-=(mat<2, 3, U, P> const & m)
 	{
 		this->value[0] -= m[0];
 		this->value[1] -= m[1];
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat2x3<T, P>& tmat2x3<T, P>::operator*=(U s)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<2, 3, T, P>& mat<2, 3, T, P>::operator*=(U s)
 	{
 		this->value[0] *= s;
 		this->value[1] *= s;
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat2x3<T, P> & tmat2x3<T, P>::operator/=(U s)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<2, 3, T, P> & mat<2, 3, T, P>::operator/=(U s)
 	{
 		this->value[0] /= s;
 		this->value[1] /= s;
@@ -245,131 +245,131 @@ namespace glm
 
 	// -- Increment and decrement operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x3<T, P> & tmat2x3<T, P>::operator++()
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<2, 3, T, P> & mat<2, 3, T, P>::operator++()
 	{
 		++this->value[0];
 		++this->value[1];
 		return *this;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x3<T, P> & tmat2x3<T, P>::operator--()
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<2, 3, T, P> & mat<2, 3, T, P>::operator--()
 	{
 		--this->value[0];
 		--this->value[1];
 		return *this;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x3<T, P> tmat2x3<T, P>::operator++(int)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<2, 3, T, P> mat<2, 3, T, P>::operator++(int)
 	{
-		tmat2x3<T, P> Result(*this);
+		mat<2, 3, T, P> Result(*this);
 		++*this;
 		return Result;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x3<T, P> tmat2x3<T, P>::operator--(int)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<2, 3, T, P> mat<2, 3, T, P>::operator--(int)
 	{
-		tmat2x3<T, P> Result(*this);
+		mat<2, 3, T, P> Result(*this);
 		--*this;
 		return Result;
 	}
 
 	// -- Unary arithmetic operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x3<T, P> operator+(tmat2x3<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<2, 3, T, P> operator+(mat<2, 3, T, P> const & m)
 	{
 		return m;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x3<T, P> operator-(tmat2x3<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<2, 3, T, P> operator-(mat<2, 3, T, P> const & m)
 	{
-		return tmat2x3<T, P>(
+		return mat<2, 3, T, P>(
 			-m[0],
 			-m[1]);
 	}
 
 	// -- Binary arithmetic operators --
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat2x3<T, P> operator+(tmat2x3<T, P> const & m, T scalar)
+	template<typename T, precision P> 
+	GLM_FUNC_QUALIFIER mat<2, 3, T, P> operator+(mat<2, 3, T, P> const & m, T scalar)
 	{
-		return tmat2x3<T, P>(
+		return mat<2, 3, T, P>(
 			m[0] + scalar,
 			m[1] + scalar);
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat2x3<T, P> operator+(tmat2x3<T, P> const & m1, tmat2x3<T, P> const & m2)
+	template<typename T, precision P> 
+	GLM_FUNC_QUALIFIER mat<2, 3, T, P> operator+(mat<2, 3, T, P> const & m1, mat<2, 3, T, P> const & m2)
 	{
-		return tmat2x3<T, P>(
+		return mat<2, 3, T, P>(
 			m1[0] + m2[0],
 			m1[1] + m2[1]);
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat2x3<T, P> operator-(tmat2x3<T, P> const & m, T scalar)
+	template<typename T, precision P> 
+	GLM_FUNC_QUALIFIER mat<2, 3, T, P> operator-(mat<2, 3, T, P> const & m, T scalar)
 	{
-		return tmat2x3<T, P>(
+		return mat<2, 3, T, P>(
 			m[0] - scalar,
 			m[1] - scalar);
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat2x3<T, P> operator-(tmat2x3<T, P> const & m1, tmat2x3<T, P> const & m2)
+	template<typename T, precision P> 
+	GLM_FUNC_QUALIFIER mat<2, 3, T, P> operator-(mat<2, 3, T, P> const & m1, mat<2, 3, T, P> const & m2)
 	{
-		return tmat2x3<T, P>(
+		return mat<2, 3, T, P>(
 			m1[0] - m2[0],
 			m1[1] - m2[1]);
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat2x3<T, P> operator*(tmat2x3<T, P> const & m, T scalar)
+	template<typename T, precision P> 
+	GLM_FUNC_QUALIFIER mat<2, 3, T, P> operator*(mat<2, 3, T, P> const & m, T scalar)
 	{
-		return tmat2x3<T, P>(
+		return mat<2, 3, T, P>(
 			m[0] * scalar,
 			m[1] * scalar);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x3<T, P> operator*(T scalar, tmat2x3<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<2, 3, T, P> operator*(T scalar, mat<2, 3, T, P> const & m)
 	{
-		return tmat2x3<T, P>(
+		return mat<2, 3, T, P>(
 			m[0] * scalar,
 			m[1] * scalar);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER typename tmat2x3<T, P>::col_type operator*
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER typename mat<2, 3, T, P>::col_type operator*
 	(
-		tmat2x3<T, P> const & m,
-		typename tmat2x3<T, P>::row_type const & v)
+		mat<2, 3, T, P> const& m,
+		typename mat<2, 3, T, P>::row_type const & v)
 	{
-		return typename tmat2x3<T, P>::col_type(
+		return typename mat<2, 3, T, P>::col_type(
 			m[0][0] * v.x + m[1][0] * v.y,
 			m[0][1] * v.x + m[1][1] * v.y,
 			m[0][2] * v.x + m[1][2] * v.y);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER typename tmat2x3<T, P>::row_type operator*
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER typename mat<2, 3, T, P>::row_type operator*
 	(
-		typename tmat2x3<T, P>::col_type const & v,
-		tmat2x3<T, P> const & m)
+		typename mat<2, 3, T, P>::col_type const & v,
+		mat<2, 3, T, P> const& m)
 	{
-		return typename tmat2x3<T, P>::row_type(
+		return typename mat<2, 3, T, P>::row_type(
 			v.x * m[0][0] + v.y * m[0][1] + v.z * m[0][2],
 			v.x * m[1][0] + v.y * m[1][1] + v.z * m[1][2]);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x3<T, P> operator*(tmat2x3<T, P> const & m1, tmat2x2<T, P> const & m2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<2, 3, T, P> operator*(mat<2, 3, T, P> const & m1, mat<2, 2, T, P> const & m2)
 	{
-		return tmat2x3<T, P>(
+		return mat<2, 3, T, P>(
 			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1],
 			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1],
 			m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1],
@@ -378,8 +378,8 @@ namespace glm
 			m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1]);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x3<T, P> operator*(tmat2x3<T, P> const & m1, tmat3x2<T, P> const & m2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, P> operator*(mat<2, 3, T, P> const & m1, mat<3, 2, T, P> const & m2)
 	{
 		T SrcA00 = m1[0][0];
 		T SrcA01 = m1[0][1];
@@ -395,7 +395,7 @@ namespace glm
 		T SrcB20 = m2[2][0];
 		T SrcB21 = m2[2][1];
 
-		tmat3x3<T, P> Result(uninitialize);
+		mat<3, 3, T, P> Result(uninitialize);
 		Result[0][0] = SrcA00 * SrcB00 + SrcA10 * SrcB01;
 		Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01;
 		Result[0][2] = SrcA02 * SrcB00 + SrcA12 * SrcB01;
@@ -408,10 +408,10 @@ namespace glm
 		return Result;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x3<T, P> operator*(tmat2x3<T, P> const & m1, tmat4x2<T, P> const & m2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, P> operator*(mat<2, 3, T, P> const & m1, mat<4, 2, T, P> const & m2)
 	{
-		return tmat4x3<T, P>(
+		return mat<4, 3, T, P>(
 			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1],
 			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1],
 			m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1],
@@ -426,32 +426,32 @@ namespace glm
 			m1[0][2] * m2[3][0] + m1[1][2] * m2[3][1]);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x3<T, P> operator/(tmat2x3<T, P> const & m, T scalar)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<2, 3, T, P> operator/(mat<2, 3, T, P> const & m, T scalar)
 	{
-		return tmat2x3<T, P>(
+		return mat<2, 3, T, P>(
 			m[0] / scalar,
 			m[1] / scalar);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x3<T, P> operator/(T scalar, tmat2x3<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<2, 3, T, P> operator/(T scalar, mat<2, 3, T, P> const & m)
 	{
-		return tmat2x3<T, P>(
+		return mat<2, 3, T, P>(
 			scalar / m[0],
 			scalar / m[1]);
 	}
 
 	// -- Boolean operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER bool operator==(tmat2x3<T, P> const & m1, tmat2x3<T, P> const & m2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER bool operator==(mat<2, 3, T, P> const & m1, mat<2, 3, T, P> const & m2)
 	{
 		return (m1[0] == m2[0]) && (m1[1] == m2[1]);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER bool operator!=(tmat2x3<T, P> const & m1, tmat2x3<T, P> const & m2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER bool operator!=(mat<2, 3, T, P> const & m1, mat<2, 3, T, P> const & m2)
 	{
 		return (m1[0] != m2[0]) || (m1[1] != m2[1]);
 	}
diff --git a/glm/detail/type_mat2x4.hpp b/glm/detail/type_mat2x4.hpp
index c9d195f7..cfe61f4e 100644
--- a/glm/detail/type_mat2x4.hpp
+++ b/glm/detail/type_mat2x4.hpp
@@ -12,13 +12,13 @@
 
 namespace glm
 {
-	template <typename T, precision P = defaultp>
-	struct tmat2x4
+	template<typename T, precision P>
+	struct mat<2, 4, T, P>
 	{
-		typedef tvec4<T, P> col_type;
-		typedef tvec2<T, P> row_type;
-		typedef tmat2x4<T, P> type;
-		typedef tmat4x2<T, P> transpose_type;
+		typedef vec<4, T, P> col_type;
+		typedef vec<2, T, P> row_type;
+		typedef mat<2, 4, T, P> type;
+		typedef mat<4, 2, T, P> transpose_type;
 		typedef T value_type;
 
 	private:
@@ -27,47 +27,47 @@ namespace glm
 	public:
 		// -- Constructors --
 
-		GLM_FUNC_DECL tmat2x4() GLM_DEFAULT_CTOR;
-		GLM_FUNC_DECL tmat2x4(tmat2x4<T, P> const & m) GLM_DEFAULT;
-		template <precision Q>
-		GLM_FUNC_DECL tmat2x4(tmat2x4<T, Q> const & m);
+		GLM_FUNC_DECL mat() GLM_DEFAULT_CTOR;
+		GLM_FUNC_DECL mat(mat<2, 4, T, P> const & m) GLM_DEFAULT;
+		template<precision Q>
+		GLM_FUNC_DECL mat(mat<2, 4, T, Q> const & m);
 
-		GLM_FUNC_DECL GLM_CONSTEXPR_CTOR explicit tmat2x4(ctor);
-		GLM_FUNC_DECL explicit tmat2x4(T scalar);
-		GLM_FUNC_DECL tmat2x4(
+		GLM_FUNC_DECL GLM_CONSTEXPR_CTOR explicit mat(ctor);
+		GLM_FUNC_DECL explicit mat(T scalar);
+		GLM_FUNC_DECL mat(
 			T x0, T y0, T z0, T w0,
 			T x1, T y1, T z1, T w1);
-		GLM_FUNC_DECL tmat2x4(
+		GLM_FUNC_DECL mat(
 			col_type const & v0,
 			col_type const & v1);
 
 		// -- Conversions --
 
-		template <
+		template<
 			typename X1, typename Y1, typename Z1, typename W1,
 			typename X2, typename Y2, typename Z2, typename W2>
-		GLM_FUNC_DECL tmat2x4(
+		GLM_FUNC_DECL mat(
 			X1 x1, Y1 y1, Z1 z1, W1 w1,
 			X2 x2, Y2 y2, Z2 z2, W2 w2);
 
-		template <typename U, typename V>
-		GLM_FUNC_DECL tmat2x4(
-			tvec4<U, P> const & v1,
-			tvec4<V, P> const & v2);
+		template<typename U, typename V>
+		GLM_FUNC_DECL mat(
+			vec<4, U, P> const & v1,
+			vec<4, V, P> const & v2);
 
 		// -- Matrix conversions --
 
-		template <typename U, precision Q>
-		GLM_FUNC_DECL GLM_EXPLICIT tmat2x4(tmat2x4<U, Q> const & m);
+		template<typename U, precision Q>
+		GLM_FUNC_DECL GLM_EXPLICIT mat(mat<2, 4, U, Q> const & m);
 
-		GLM_FUNC_DECL GLM_EXPLICIT tmat2x4(tmat2x2<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat2x4(tmat3x3<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat2x4(tmat4x4<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat2x4(tmat2x3<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat2x4(tmat3x2<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat2x4(tmat3x4<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat2x4(tmat4x2<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat2x4(tmat4x3<T, P> const & x);
+		GLM_FUNC_DECL GLM_EXPLICIT mat(mat<2, 2, T, P> const & x);
+		GLM_FUNC_DECL GLM_EXPLICIT mat(mat<3, 3, T, P> const & x);
+		GLM_FUNC_DECL GLM_EXPLICIT mat(mat<4, 4, T, P> const & x);
+		GLM_FUNC_DECL GLM_EXPLICIT mat(mat<2, 3, T, P> const & x);
+		GLM_FUNC_DECL GLM_EXPLICIT mat(mat<3, 2, T, P> const & x);
+		GLM_FUNC_DECL GLM_EXPLICIT mat(mat<3, 4, T, P> const & x);
+		GLM_FUNC_DECL GLM_EXPLICIT mat(mat<4, 2, T, P> const & x);
+		GLM_FUNC_DECL GLM_EXPLICIT mat(mat<4, 3, T, P> const & x);
 
 		// -- Accesses --
 
@@ -79,87 +79,87 @@ namespace glm
 
 		// -- Unary arithmetic operators --
 
-		GLM_FUNC_DECL tmat2x4<T, P> & operator=(tmat2x4<T, P> const & m) GLM_DEFAULT;
+		GLM_FUNC_DECL mat<2, 4, T, P> & operator=(mat<2, 4, T, P> const & m) GLM_DEFAULT;
 
-		template <typename U>
-		GLM_FUNC_DECL tmat2x4<T, P> & operator=(tmat2x4<U, P> const & m);
-		template <typename U>
-		GLM_FUNC_DECL tmat2x4<T, P> & operator+=(U s);
-		template <typename U>
-		GLM_FUNC_DECL tmat2x4<T, P> & operator+=(tmat2x4<U, P> const & m);
-		template <typename U>
-		GLM_FUNC_DECL tmat2x4<T, P> & operator-=(U s);
-		template <typename U>
-		GLM_FUNC_DECL tmat2x4<T, P> & operator-=(tmat2x4<U, P> const & m);
-		template <typename U>
-		GLM_FUNC_DECL tmat2x4<T, P> & operator*=(U s);
-		template <typename U>
-		GLM_FUNC_DECL tmat2x4<T, P> & operator/=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<2, 4, T, P> & operator=(mat<2, 4, U, P> const & m);
+		template<typename U>
+		GLM_FUNC_DECL mat<2, 4, T, P> & operator+=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<2, 4, T, P> & operator+=(mat<2, 4, U, P> const & m);
+		template<typename U>
+		GLM_FUNC_DECL mat<2, 4, T, P> & operator-=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<2, 4, T, P> & operator-=(mat<2, 4, U, P> const & m);
+		template<typename U>
+		GLM_FUNC_DECL mat<2, 4, T, P> & operator*=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<2, 4, T, P> & operator/=(U s);
 
 		// -- Increment and decrement operators --
 
-		GLM_FUNC_DECL tmat2x4<T, P> & operator++ ();
-		GLM_FUNC_DECL tmat2x4<T, P> & operator-- ();
-		GLM_FUNC_DECL tmat2x4<T, P> operator++(int);
-		GLM_FUNC_DECL tmat2x4<T, P> operator--(int);
+		GLM_FUNC_DECL mat<2, 4, T, P> & operator++ ();
+		GLM_FUNC_DECL mat<2, 4, T, P> & operator-- ();
+		GLM_FUNC_DECL mat<2, 4, T, P> operator++(int);
+		GLM_FUNC_DECL mat<2, 4, T, P> operator--(int);
 	};
 
 	// -- Unary operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x4<T, P> operator+(tmat2x4<T, P> const & m);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<2, 4, T, P> operator+(mat<2, 4, T, P> const & m);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x4<T, P> operator-(tmat2x4<T, P> const & m);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<2, 4, T, P> operator-(mat<2, 4, T, P> const & m);
 
 	// -- Binary operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x4<T, P> operator+(tmat2x4<T, P> const & m, T scalar);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<2, 4, T, P> operator+(mat<2, 4, T, P> const & m, T scalar);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x4<T, P> operator+(tmat2x4<T, P> const & m1, tmat2x4<T, P> const & m2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<2, 4, T, P> operator+(mat<2, 4, T, P> const & m1, mat<2, 4, T, P> const & m2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x4<T, P> operator-(tmat2x4<T, P> const & m, T scalar);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<2, 4, T, P> operator-(mat<2, 4, T, P> const & m, T scalar);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x4<T, P> operator-(tmat2x4<T, P> const & m1, tmat2x4<T, P> const & m2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<2, 4, T, P> operator-(mat<2, 4, T, P> const & m1, mat<2, 4, T, P> const & m2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x4<T, P> operator*(tmat2x4<T, P> const & m, T scalar);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<2, 4, T, P> operator*(mat<2, 4, T, P> const & m, T scalar);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x4<T, P> operator*(T scalar, tmat2x4<T, P> const & m);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<2, 4, T, P> operator*(T scalar, mat<2, 4, T, P> const & m);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL typename tmat2x4<T, P>::col_type operator*(tmat2x4<T, P> const & m, typename tmat2x4<T, P>::row_type const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL typename mat<2, 4, T, P>::col_type operator*(mat<2, 4, T, P> const & m, typename mat<2, 4, T, P>::row_type const & v);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL typename tmat2x4<T, P>::row_type operator*(typename tmat2x4<T, P>::col_type const & v, tmat2x4<T, P> const & m);
+	template<typename T, precision P>
+	GLM_FUNC_DECL typename mat<2, 4, T, P>::row_type operator*(typename mat<2, 4, T, P>::col_type const & v, mat<2, 4, T, P> const & m);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat4x4<T, P> operator*(tmat2x4<T, P> const & m1, tmat4x2<T, P> const & m2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<4, 4, T, P> operator*(mat<2, 4, T, P> const & m1, mat<4, 2, T, P> const & m2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x4<T, P> operator*(tmat2x4<T, P> const & m1, tmat2x2<T, P> const & m2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<2, 4, T, P> operator*(mat<2, 4, T, P> const & m1, mat<2, 2, T, P> const & m2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat3x4<T, P> operator*(tmat2x4<T, P> const & m1, tmat3x2<T, P> const & m2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<3, 4, T, P> operator*(mat<2, 4, T, P> const & m1, mat<3, 2, T, P> const & m2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x4<T, P> operator/(tmat2x4<T, P> const & m, T scalar);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<2, 4, T, P> operator/(mat<2, 4, T, P> const & m, T scalar);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x4<T, P> operator/(T scalar, tmat2x4<T, P> const & m);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<2, 4, T, P> operator/(T scalar, mat<2, 4, T, P> const & m);
 
 	// -- Boolean operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL bool operator==(tmat2x4<T, P> const & m1, tmat2x4<T, P> const & m2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL bool operator==(mat<2, 4, T, P> const & m1, mat<2, 4, T, P> const & m2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL bool operator!=(tmat2x4<T, P> const & m1, tmat2x4<T, P> const & m2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL bool operator!=(mat<2, 4, T, P> const & m1, mat<2, 4, T, P> const & m2);
 }//namespace glm
 
 #ifndef GLM_EXTERNAL_TEMPLATE
diff --git a/glm/detail/type_mat2x4.inl b/glm/detail/type_mat2x4.inl
index 74af34c6..ee9c3c42 100644
--- a/glm/detail/type_mat2x4.inl
+++ b/glm/detail/type_mat2x4.inl
@@ -6,8 +6,8 @@ namespace glm
 	// -- Constructors --
 
 #	if !GLM_HAS_DEFAULTED_FUNCTIONS || !defined(GLM_FORCE_NO_CTOR_INIT)
-		template <typename T, precision P>
-		GLM_FUNC_QUALIFIER tmat2x4<T, P>::tmat2x4()
+		template<typename T, precision P>
+		GLM_FUNC_QUALIFIER mat<2, 4, T, P>::mat()
 		{
 #			ifndef GLM_FORCE_NO_CTOR_INIT 
 				this->value[0] = col_type(1, 0, 0, 0);
@@ -17,36 +17,36 @@ namespace glm
 #	endif
 
 #	if !GLM_HAS_DEFAULTED_FUNCTIONS
-		template <typename T, precision P>
-		GLM_FUNC_QUALIFIER tmat2x4<T, P>::tmat2x4(tmat2x4<T, P> const & m)
+		template<typename T, precision P>
+		GLM_FUNC_QUALIFIER mat<2, 4, T, P>::mat(mat<2, 4, T, P> const & m)
 		{
 			this->value[0] = m.value[0];
 			this->value[1] = m.value[1];
 		}
 #	endif//!GLM_HAS_DEFAULTED_FUNCTIONS
 
-	template <typename T, precision P>
-	template <precision Q>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P>::tmat2x4(tmat2x4<T, Q> const & m)
+	template<typename T, precision P>
+	template<precision Q>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, P>::mat(mat<2, 4, T, Q> const & m)
 	{
 		this->value[0] = m.value[0];
 		this->value[1] = m.value[1];
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR tmat2x4<T, P>::tmat2x4(ctor)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR mat<2, 4, T, P>::mat(ctor)
 	{}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P>::tmat2x4(T scalar)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, P>::mat(T scalar)
 	{
 		value_type const Zero(0);
 		this->value[0] = col_type(scalar, Zero, Zero, Zero);
 		this->value[1] = col_type(Zero, scalar, Zero, Zero);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P>::tmat2x4
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, P>::mat
 	(
 		T x0, T y0, T z0, T w0,
 		T x1, T y1, T z1, T w1
@@ -56,8 +56,8 @@ namespace glm
 		this->value[1] = col_type(x1, y1, z1, w1);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P>::tmat2x4(col_type const & v0, col_type const & v1)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, P>::mat(col_type const & v0, col_type const & v1)
 	{
 		this->value[0] = v0;
 		this->value[1] = v1;
@@ -65,11 +65,11 @@ namespace glm
 
 	// -- Conversion constructors --
 
-	template <typename T, precision P>
-	template <
+	template<typename T, precision P>
+	template<
 		typename X1, typename Y1, typename Z1, typename W1,
 		typename X2, typename Y2, typename Z2, typename W2>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P>::tmat2x4
+	GLM_FUNC_QUALIFIER mat<2, 4, T, P>::mat
 	(
 		X1 x1, Y1 y1, Z1 z1, W1 w1,
 		X2 x2, Y2 y2, Z2 z2, W2 w2
@@ -79,9 +79,9 @@ namespace glm
 		this->value[1] = col_type(static_cast<T>(x2), value_type(y2), value_type(z2), value_type(w2));
 	}
 	
-	template <typename T, precision P>
-	template <typename V1, typename V2>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P>::tmat2x4(tvec4<V1, P> const & v1, tvec4<V2, P> const & v2)
+	template<typename T, precision P>
+	template<typename V1, typename V2>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, P>::mat(vec<4, V1, P> const & v1, vec<4, V2, P> const & v2)
 	{
 		this->value[0] = col_type(v1);
 		this->value[1] = col_type(v2);
@@ -89,65 +89,65 @@ namespace glm
 
 	// -- Matrix conversions --
 
-	template <typename T, precision P>
-	template <typename U, precision Q>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P>::tmat2x4(tmat2x4<U, Q> const & m)
+	template<typename T, precision P>
+	template<typename U, precision Q>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, P>::mat(mat<2, 4, U, Q> const & m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P>::tmat2x4(tmat2x2<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, P>::mat(mat<2, 2, T, P> const & m)
 	{
 		this->value[0] = col_type(m[0], 0, 0);
 		this->value[1] = col_type(m[1], 0, 0);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P>::tmat2x4(tmat3x3<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, P>::mat(mat<3, 3, T, P> const & m)
 	{
 		this->value[0] = col_type(m[0], 0);
 		this->value[1] = col_type(m[1], 0);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P>::tmat2x4(tmat4x4<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, P>::mat(mat<4, 4, T, P> const & m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P>::tmat2x4(tmat2x3<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, P>::mat(mat<2, 3, T, P> const & m)
 	{
 		this->value[0] = col_type(m[0], 0);
 		this->value[1] = col_type(m[1], 0);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P>::tmat2x4(tmat3x2<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, P>::mat(mat<3, 2, T, P> const & m)
 	{
 		this->value[0] = col_type(m[0], 0, 0);
 		this->value[1] = col_type(m[1], 0, 0);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P>::tmat2x4(tmat3x4<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, P>::mat(mat<3, 4, T, P> const & m)
 	{
 		this->value[0] = m[0];
 		this->value[1] = m[1];
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P>::tmat2x4(tmat4x2<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, P>::mat(mat<4, 2, T, P> const & m)
 	{
 		this->value[0] = col_type(m[0], 0, 0);
 		this->value[1] = col_type(m[1], 0, 0);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P>::tmat2x4(tmat4x3<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, P>::mat(mat<4, 3, T, P> const & m)
 	{
 		this->value[0] = col_type(m[0], 0);
 		this->value[1] = col_type(m[1], 0);
@@ -155,15 +155,15 @@ namespace glm
 
 	// -- Accesses --
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER typename tmat2x4<T, P>::col_type & tmat2x4<T, P>::operator[](typename tmat2x4<T, P>::length_type i)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER typename mat<2, 4, T, P>::col_type & mat<2, 4, T, P>::operator[](typename mat<2, 4, T, P>::length_type i)
 	{
 		assert(i < this->length());
 		return this->value[i];
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER typename tmat2x4<T, P>::col_type const & tmat2x4<T, P>::operator[](typename tmat2x4<T, P>::length_type i) const
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER typename mat<2, 4, T, P>::col_type const & mat<2, 4, T, P>::operator[](typename mat<2, 4, T, P>::length_type i) const
 	{
 		assert(i < this->length());
 		return this->value[i];
@@ -172,8 +172,8 @@ namespace glm
 	// -- Unary updatable operators --
 
 #	if !GLM_HAS_DEFAULTED_FUNCTIONS
-		template <typename T, precision P>
-		GLM_FUNC_QUALIFIER tmat2x4<T, P>& tmat2x4<T, P>::operator=(tmat2x4<T, P> const & m)
+		template<typename T, precision P>
+		GLM_FUNC_QUALIFIER mat<2, 4, T, P>& mat<2, 4, T, P>::operator=(mat<2, 4, T, P> const & m)
 		{
 			this->value[0] = m[0];
 			this->value[1] = m[1];
@@ -181,63 +181,63 @@ namespace glm
 		}
 #	endif//!GLM_HAS_DEFAULTED_FUNCTIONS
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P>& tmat2x4<T, P>::operator=(tmat2x4<U, P> const & m)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, P>& mat<2, 4, T, P>::operator=(mat<2, 4, U, P> const & m)
 	{
 		this->value[0] = m[0];
 		this->value[1] = m[1];
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P>& tmat2x4<T, P>::operator+=(U s)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, P>& mat<2, 4, T, P>::operator+=(U s)
 	{
 		this->value[0] += s;
 		this->value[1] += s;
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P>& tmat2x4<T, P>::operator+=(tmat2x4<U, P> const & m)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, P>& mat<2, 4, T, P>::operator+=(mat<2, 4, U, P> const & m)
 	{
 		this->value[0] += m[0];
 		this->value[1] += m[1];
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P>& tmat2x4<T, P>::operator-=(U s)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, P>& mat<2, 4, T, P>::operator-=(U s)
 	{
 		this->value[0] -= s;
 		this->value[1] -= s;
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P>& tmat2x4<T, P>::operator-=(tmat2x4<U, P> const & m)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, P>& mat<2, 4, T, P>::operator-=(mat<2, 4, U, P> const & m)
 	{
 		this->value[0] -= m[0];
 		this->value[1] -= m[1];
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P>& tmat2x4<T, P>::operator*=(U s)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, P>& mat<2, 4, T, P>::operator*=(U s)
 	{
 		this->value[0] *= s;
 		this->value[1] *= s;
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P> & tmat2x4<T, P>::operator/=(U s)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, P> & mat<2, 4, T, P>::operator/=(U s)
 	{
 		this->value[0] /= s;
 		this->value[1] /= s;
@@ -246,124 +246,124 @@ namespace glm
 
 	// -- Increment and decrement operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P>& tmat2x4<T, P>::operator++()
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, P>& mat<2, 4, T, P>::operator++()
 	{
 		++this->value[0];
 		++this->value[1];
 		return *this;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P>& tmat2x4<T, P>::operator--()
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, P>& mat<2, 4, T, P>::operator--()
 	{
 		--this->value[0];
 		--this->value[1];
 		return *this;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P> tmat2x4<T, P>::operator++(int)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, P> mat<2, 4, T, P>::operator++(int)
 	{
-		tmat2x4<T, P> Result(*this);
+		mat<2, 4, T, P> Result(*this);
 		++*this;
 		return Result;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P> tmat2x4<T, P>::operator--(int)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, P> mat<2, 4, T, P>::operator--(int)
 	{
-		tmat2x4<T, P> Result(*this);
+		mat<2, 4, T, P> Result(*this);
 		--*this;
 		return Result;
 	}
 
 	// -- Unary arithmetic operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P> operator+(tmat2x4<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, P> operator+(mat<2, 4, T, P> const & m)
 	{
 		return m;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P> operator-(tmat2x4<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, P> operator-(mat<2, 4, T, P> const & m)
 	{
-		return tmat2x4<T, P>(
+		return mat<2, 4, T, P>(
 			-m[0], 
 			-m[1]);
 	}
 
 	// -- Binary arithmetic operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P> operator+(tmat2x4<T, P> const & m, T scalar)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, P> operator+(mat<2, 4, T, P> const & m, T scalar)
 	{
-		return tmat2x4<T, P>(
+		return mat<2, 4, T, P>(
 			m[0] + scalar,
 			m[1] + scalar);
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat2x4<T, P> operator+(tmat2x4<T, P> const & m1, tmat2x4<T, P> const & m2)
+	template<typename T, precision P> 
+	GLM_FUNC_QUALIFIER mat<2, 4, T, P> operator+(mat<2, 4, T, P> const & m1, mat<2, 4, T, P> const & m2)
 	{
-		return tmat2x4<T, P>(
+		return mat<2, 4, T, P>(
 			m1[0] + m2[0],
 			m1[1] + m2[1]);
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat2x4<T, P> operator-(tmat2x4<T, P> const & m, T scalar)
+	template<typename T, precision P> 
+	GLM_FUNC_QUALIFIER mat<2, 4, T, P> operator-(mat<2, 4, T, P> const & m, T scalar)
 	{
-		return tmat2x4<T, P>(
+		return mat<2, 4, T, P>(
 			m[0] - scalar,
 			m[1] - scalar);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P> operator-(tmat2x4<T, P> const & m1, tmat2x4<T, P> const & m2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, P> operator-(mat<2, 4, T, P> const & m1, mat<2, 4, T, P> const & m2)
 	{
-		return tmat2x4<T, P>(
+		return mat<2, 4, T, P>(
 			m1[0] - m2[0],
 			m1[1] - m2[1]);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P> operator*(tmat2x4<T, P> const & m, T scalar)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, P> operator*(mat<2, 4, T, P> const & m, T scalar)
 	{
-		return tmat2x4<T, P>(
+		return mat<2, 4, T, P>(
 			m[0] * scalar,
 			m[1] * scalar);
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat2x4<T, P> operator*(T scalar, tmat2x4<T, P> const & m)
+	template<typename T, precision P> 
+	GLM_FUNC_QUALIFIER mat<2, 4, T, P> operator*(T scalar, mat<2, 4, T, P> const & m)
 	{
-		return tmat2x4<T, P>(
+		return mat<2, 4, T, P>(
 			m[0] * scalar,
 			m[1] * scalar);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER typename tmat2x4<T, P>::col_type operator*(tmat2x4<T, P> const & m, typename tmat2x4<T, P>::row_type const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER typename mat<2, 4, T, P>::col_type operator*(mat<2, 4, T, P> const & m, typename mat<2, 4, T, P>::row_type const & v)
 	{
-		return typename tmat2x4<T, P>::col_type(
+		return typename mat<2, 4, T, P>::col_type(
 			m[0][0] * v.x + m[1][0] * v.y,
 			m[0][1] * v.x + m[1][1] * v.y,
 			m[0][2] * v.x + m[1][2] * v.y,
 			m[0][3] * v.x + m[1][3] * v.y);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER typename tmat2x4<T, P>::row_type operator*(typename tmat2x4<T, P>::col_type const & v, tmat2x4<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER typename mat<2, 4, T, P>::row_type operator*(typename mat<2, 4, T, P>::col_type const & v, mat<2, 4, T, P> const & m)
 	{
-		return typename tmat2x4<T, P>::row_type(
+		return typename mat<2, 4, T, P>::row_type(
 			v.x * m[0][0] + v.y * m[0][1] + v.z * m[0][2] + v.w * m[0][3],
 			v.x * m[1][0] + v.y * m[1][1] + v.z * m[1][2] + v.w * m[1][3]);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> operator*(tmat2x4<T, P> const & m1, tmat4x2<T, P> const & m2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, P> operator*(mat<2, 4, T, P> const & m1, mat<4, 2, T, P> const & m2)
 	{
 		T SrcA00 = m1[0][0];
 		T SrcA01 = m1[0][1];
@@ -383,7 +383,7 @@ namespace glm
 		T SrcB30 = m2[3][0];
 		T SrcB31 = m2[3][1];
 
-		tmat4x4<T, P> Result(uninitialize);
+		mat<4, 4, T, P> Result(uninitialize);
 		Result[0][0] = SrcA00 * SrcB00 + SrcA10 * SrcB01;
 		Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01;
 		Result[0][2] = SrcA02 * SrcB00 + SrcA12 * SrcB01;
@@ -403,10 +403,10 @@ namespace glm
 		return Result;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P> operator*(tmat2x4<T, P> const & m1, tmat2x2<T, P> const & m2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, P> operator*(mat<2, 4, T, P> const & m1, mat<2, 2, T, P> const & m2)
 	{
-		return tmat2x4<T, P>(
+		return mat<2, 4, T, P>(
 			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1],
 			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1],
 			m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1],
@@ -417,10 +417,10 @@ namespace glm
 			m1[0][3] * m2[1][0] + m1[1][3] * m2[1][1]);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x4<T, P> operator*(tmat2x4<T, P> const & m1, tmat3x2<T, P> const & m2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, P> operator*(mat<2, 4, T, P> const & m1, mat<3, 2, T, P> const & m2)
 	{
-		return tmat3x4<T, P>(
+		return mat<3, 4, T, P>(
 			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1],
 			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1],
 			m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1],
@@ -435,32 +435,32 @@ namespace glm
 			m1[0][3] * m2[2][0] + m1[1][3] * m2[2][1]);
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat2x4<T, P> operator/(tmat2x4<T, P> const & m, T scalar)
+	template<typename T, precision P> 
+	GLM_FUNC_QUALIFIER mat<2, 4, T, P> operator/(mat<2, 4, T, P> const & m, T scalar)
 	{
-		return tmat2x4<T, P>(
+		return mat<2, 4, T, P>(
 			m[0] / scalar,
 			m[1] / scalar);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P> operator/(T scalar, tmat2x4<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, P> operator/(T scalar, mat<2, 4, T, P> const & m)
 	{
-		return tmat2x4<T, P>(
+		return mat<2, 4, T, P>(
 			scalar / m[0],
 			scalar / m[1]);
 	}
 
 	// -- Boolean operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER bool operator==(tmat2x4<T, P> const & m1, tmat2x4<T, P> const & m2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER bool operator==(mat<2, 4, T, P> const & m1, mat<2, 4, T, P> const & m2)
 	{
 		return (m1[0] == m2[0]) && (m1[1] == m2[1]);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER bool operator!=(tmat2x4<T, P> const & m1, tmat2x4<T, P> const & m2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER bool operator!=(mat<2, 4, T, P> const & m1, mat<2, 4, T, P> const & m2)
 	{
 		return (m1[0] != m2[0]) || (m1[1] != m2[1]);
 	}
diff --git a/glm/detail/type_mat3x2.hpp b/glm/detail/type_mat3x2.hpp
index 8549745e..f738dc60 100644
--- a/glm/detail/type_mat3x2.hpp
+++ b/glm/detail/type_mat3x2.hpp
@@ -12,13 +12,13 @@
 
 namespace glm
 {
-	template <typename T, precision P = defaultp>
-	struct tmat3x2
+	template<typename T, precision P>
+	struct mat<3, 2, T, P>
 	{
-		typedef tvec2<T, P> col_type;
-		typedef tvec3<T, P> row_type;
-		typedef tmat3x2<T, P> type;
-		typedef tmat2x3<T, P> transpose_type;
+		typedef vec<2, T, P> col_type;
+		typedef vec<3, T, P> row_type;
+		typedef mat<3, 2, T, P> type;
+		typedef mat<2, 3, T, P> transpose_type;
 		typedef T value_type;
 
 	private:
@@ -27,18 +27,18 @@ namespace glm
 	public:
 		// -- Constructors --
 
-		GLM_FUNC_DECL tmat3x2() GLM_DEFAULT_CTOR;
-		GLM_FUNC_DECL tmat3x2(tmat3x2<T, P> const & m) GLM_DEFAULT;
-		template <precision Q>
-		GLM_FUNC_DECL tmat3x2(tmat3x2<T, Q> const & m);
+		GLM_FUNC_DECL mat() GLM_DEFAULT_CTOR;
+		GLM_FUNC_DECL mat(mat<3, 2, T, P> const & m) GLM_DEFAULT;
+		template<precision Q>
+		GLM_FUNC_DECL mat(mat<3, 2, T, Q> const & m);
 
-		GLM_FUNC_DECL GLM_CONSTEXPR_CTOR explicit tmat3x2(ctor);
-		GLM_FUNC_DECL explicit tmat3x2(T scalar);
-		GLM_FUNC_DECL tmat3x2(
+		GLM_FUNC_DECL GLM_CONSTEXPR_CTOR explicit mat(ctor);
+		GLM_FUNC_DECL explicit mat(T scalar);
+		GLM_FUNC_DECL mat(
 			T x0, T y0,
 			T x1, T y1,
 			T x2, T y2);
-		GLM_FUNC_DECL tmat3x2(
+		GLM_FUNC_DECL mat(
 			col_type const & v0,
 			col_type const & v1,
 			col_type const & v2);
@@ -49,30 +49,30 @@ namespace glm
 			typename X1, typename Y1,
 			typename X2, typename Y2,
 			typename X3, typename Y3>
-		GLM_FUNC_DECL tmat3x2(
+		GLM_FUNC_DECL mat(
 			X1 x1, Y1 y1,
 			X2 x2, Y2 y2,
 			X3 x3, Y3 y3);
 
-		template <typename V1, typename V2, typename V3>
-		GLM_FUNC_DECL tmat3x2(
-			tvec2<V1, P> const & v1,
-			tvec2<V2, P> const & v2,
-			tvec2<V3, P> const & v3);
+		template<typename V1, typename V2, typename V3>
+		GLM_FUNC_DECL mat(
+			vec<2, V1, P> const & v1,
+			vec<2, V2, P> const & v2,
+			vec<2, V3, P> const & v3);
 
 		// -- Matrix conversions --
 
-		template <typename U, precision Q>
-		GLM_FUNC_DECL GLM_EXPLICIT tmat3x2(tmat3x2<U, Q> const & m);
+		template<typename U, precision Q>
+		GLM_FUNC_DECL GLM_EXPLICIT mat(mat<3, 2, U, Q> const & m);
 
-		GLM_FUNC_DECL GLM_EXPLICIT tmat3x2(tmat2x2<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat3x2(tmat3x3<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat3x2(tmat4x4<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat3x2(tmat2x3<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat3x2(tmat2x4<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat3x2(tmat3x4<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat3x2(tmat4x2<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat3x2(tmat4x3<T, P> const & x);
+		GLM_FUNC_DECL GLM_EXPLICIT mat(mat<2, 2, T, P> const & x);
+		GLM_FUNC_DECL GLM_EXPLICIT mat(mat<3, 3, T, P> const & x);
+		GLM_FUNC_DECL GLM_EXPLICIT mat(mat<4, 4, T, P> const & x);
+		GLM_FUNC_DECL GLM_EXPLICIT mat(mat<2, 3, T, P> const & x);
+		GLM_FUNC_DECL GLM_EXPLICIT mat(mat<2, 4, T, P> const & x);
+		GLM_FUNC_DECL GLM_EXPLICIT mat(mat<3, 4, T, P> const & x);
+		GLM_FUNC_DECL GLM_EXPLICIT mat(mat<4, 2, T, P> const & x);
+		GLM_FUNC_DECL GLM_EXPLICIT mat(mat<4, 3, T, P> const & x);
 
 		// -- Accesses --
 
@@ -84,87 +84,87 @@ namespace glm
 
 		// -- Unary arithmetic operators --
 
-		GLM_FUNC_DECL tmat3x2<T, P> & operator=(tmat3x2<T, P> const & m) GLM_DEFAULT;
+		GLM_FUNC_DECL mat<3, 2, T, P> & operator=(mat<3, 2, T, P> const & m) GLM_DEFAULT;
 
-		template <typename U>
-		GLM_FUNC_DECL tmat3x2<T, P> & operator=(tmat3x2<U, P> const & m);
-		template <typename U>
-		GLM_FUNC_DECL tmat3x2<T, P> & operator+=(U s);
-		template <typename U>
-		GLM_FUNC_DECL tmat3x2<T, P> & operator+=(tmat3x2<U, P> const & m);
-		template <typename U>
-		GLM_FUNC_DECL tmat3x2<T, P> & operator-=(U s);
-		template <typename U>
-		GLM_FUNC_DECL tmat3x2<T, P> & operator-=(tmat3x2<U, P> const & m);
-		template <typename U>
-		GLM_FUNC_DECL tmat3x2<T, P> & operator*=(U s);
-		template <typename U>
-		GLM_FUNC_DECL tmat3x2<T, P> & operator/=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<3, 2, T, P> & operator=(mat<3, 2, U, P> const & m);
+		template<typename U>
+		GLM_FUNC_DECL mat<3, 2, T, P> & operator+=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<3, 2, T, P> & operator+=(mat<3, 2, U, P> const & m);
+		template<typename U>
+		GLM_FUNC_DECL mat<3, 2, T, P> & operator-=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<3, 2, T, P> & operator-=(mat<3, 2, U, P> const & m);
+		template<typename U>
+		GLM_FUNC_DECL mat<3, 2, T, P> & operator*=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<3, 2, T, P> & operator/=(U s);
 
 		// -- Increment and decrement operators --
 
-		GLM_FUNC_DECL tmat3x2<T, P> & operator++ ();
-		GLM_FUNC_DECL tmat3x2<T, P> & operator-- ();
-		GLM_FUNC_DECL tmat3x2<T, P> operator++(int);
-		GLM_FUNC_DECL tmat3x2<T, P> operator--(int);
+		GLM_FUNC_DECL mat<3, 2, T, P> & operator++ ();
+		GLM_FUNC_DECL mat<3, 2, T, P> & operator-- ();
+		GLM_FUNC_DECL mat<3, 2, T, P> operator++(int);
+		GLM_FUNC_DECL mat<3, 2, T, P> operator--(int);
 	};
 
 	// -- Unary operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat3x2<T, P> operator+(tmat3x2<T, P> const & m);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<3, 2, T, P> operator+(mat<3, 2, T, P> const & m);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat3x2<T, P> operator-(tmat3x2<T, P> const & m);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<3, 2, T, P> operator-(mat<3, 2, T, P> const & m);
 
 	// -- Binary operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat3x2<T, P> operator+(tmat3x2<T, P> const & m, T scalar);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<3, 2, T, P> operator+(mat<3, 2, T, P> const & m, T scalar);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat3x2<T, P> operator+(tmat3x2<T, P> const & m1, tmat3x2<T, P> const & m2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<3, 2, T, P> operator+(mat<3, 2, T, P> const & m1, mat<3, 2, T, P> const & m2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat3x2<T, P> operator-(tmat3x2<T, P> const & m, T scalar);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<3, 2, T, P> operator-(mat<3, 2, T, P> const & m, T scalar);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat3x2<T, P> operator-(tmat3x2<T, P> const & m1, tmat3x2<T, P> const & m2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<3, 2, T, P> operator-(mat<3, 2, T, P> const & m1, mat<3, 2, T, P> const & m2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat3x2<T, P> operator*(tmat3x2<T, P> const & m, T scalar);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<3, 2, T, P> operator*(mat<3, 2, T, P> const & m, T scalar);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat3x2<T, P> operator*(T scalar, tmat3x2<T, P> const & m);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<3, 2, T, P> operator*(T scalar, mat<3, 2, T, P> const & m);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL typename tmat3x2<T, P>::col_type operator*(tmat3x2<T, P> const & m, typename tmat3x2<T, P>::row_type const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL typename mat<3, 2, T, P>::col_type operator*(mat<3, 2, T, P> const & m, typename mat<3, 2, T, P>::row_type const & v);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL typename tmat3x2<T, P>::row_type operator*(typename tmat3x2<T, P>::col_type const & v, tmat3x2<T, P> const & m);
+	template<typename T, precision P>
+	GLM_FUNC_DECL typename mat<3, 2, T, P>::row_type operator*(typename mat<3, 2, T, P>::col_type const & v, mat<3, 2, T, P> const & m);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x2<T, P> operator*(tmat3x2<T, P> const & m1, tmat2x3<T, P> const & m2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<2, 2, T, P> operator*(mat<3, 2, T, P> const & m1, mat<2, 3, T, P> const & m2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat3x2<T, P> operator*(tmat3x2<T, P> const & m1, tmat3x3<T, P> const & m2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<3, 2, T, P> operator*(mat<3, 2, T, P> const & m1, mat<3, 3, T, P> const & m2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat4x2<T, P> operator*(tmat3x2<T, P> const & m1, tmat4x3<T, P> const & m2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<4, 2, T, P> operator*(mat<3, 2, T, P> const & m1, mat<4, 3, T, P> const & m2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat3x2<T, P> operator/(tmat3x2<T, P> const & m, T scalar);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<3, 2, T, P> operator/(mat<3, 2, T, P> const & m, T scalar);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat3x2<T, P> operator/(T scalar, tmat3x2<T, P> const & m);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<3, 2, T, P> operator/(T scalar, mat<3, 2, T, P> const & m);
 
 	// -- Boolean operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL bool operator==(tmat3x2<T, P> const & m1, tmat3x2<T, P> const & m2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL bool operator==(mat<3, 2, T, P> const & m1, mat<3, 2, T, P> const & m2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL bool operator!=(tmat3x2<T, P> const & m1, tmat3x2<T, P> const & m2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL bool operator!=(mat<3, 2, T, P> const & m1, mat<3, 2, T, P> const & m2);
 
 }//namespace glm
 
diff --git a/glm/detail/type_mat3x2.inl b/glm/detail/type_mat3x2.inl
index 2a1b8bd6..9f66a015 100644
--- a/glm/detail/type_mat3x2.inl
+++ b/glm/detail/type_mat3x2.inl
@@ -6,8 +6,8 @@ namespace glm
 	// -- Constructors --
 
 #	if !GLM_HAS_DEFAULTED_FUNCTIONS || !defined(GLM_FORCE_NO_CTOR_INIT)
-		template <typename T, precision P> 
-		GLM_FUNC_QUALIFIER tmat3x2<T, P>::tmat3x2()
+		template<typename T, precision P> 
+		GLM_FUNC_QUALIFIER mat<3, 2, T, P>::mat()
 		{
 #			ifndef GLM_FORCE_NO_CTOR_INIT 
 				this->value[0] = col_type(1, 0);
@@ -18,8 +18,8 @@ namespace glm
 #	endif
 
 #	if !GLM_HAS_DEFAULTED_FUNCTIONS
-		template <typename T, precision P>
-		GLM_FUNC_QUALIFIER tmat3x2<T, P>::tmat3x2(tmat3x2<T, P> const & m)
+		template<typename T, precision P>
+		GLM_FUNC_QUALIFIER mat<3, 2, T, P>::mat(mat<3, 2, T, P> const & m)
 		{
 			this->value[0] = m.value[0];
 			this->value[1] = m.value[1];
@@ -27,29 +27,29 @@ namespace glm
 		}
 #	endif//!GLM_HAS_DEFAULTED_FUNCTIONS
 
-	template <typename T, precision P>
-	template <precision Q>
-	GLM_FUNC_QUALIFIER tmat3x2<T, P>::tmat3x2(tmat3x2<T, Q> const & m)
+	template<typename T, precision P>
+	template<precision Q>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, P>::mat(mat<3, 2, T, Q> const & m)
 	{
 		this->value[0] = m.value[0];
 		this->value[1] = m.value[1];
 		this->value[2] = m.value[2];
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR tmat3x2<T, P>::tmat3x2(ctor)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR mat<3, 2, T, P>::mat(ctor)
 	{}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x2<T, P>::tmat3x2(T scalar)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, P>::mat(T scalar)
 	{
 		this->value[0] = col_type(scalar, 0);
 		this->value[1] = col_type(0, scalar);
 		this->value[2] = col_type(0, 0);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x2<T, P>::tmat3x2
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, P>::mat
 	(
 		T x0, T y0,
 		T x1, T y1,
@@ -61,8 +61,8 @@ namespace glm
 		this->value[2] = col_type(x2, y2);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x2<T, P>::tmat3x2
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, P>::mat
 	(
 		col_type const & v0,
 		col_type const & v1,
@@ -76,12 +76,12 @@ namespace glm
 
 	// -- Conversion constructors --
 
-	template <typename T, precision P>
-	template <
+	template<typename T, precision P>
+	template<
 		typename X1, typename Y1,
 		typename X2, typename Y2,
 		typename X3, typename Y3>
-	GLM_FUNC_QUALIFIER tmat3x2<T, P>::tmat3x2
+	GLM_FUNC_QUALIFIER mat<3, 2, T, P>::mat
 	(
 		X1 x1, Y1 y1,
 		X2 x2, Y2 y2,
@@ -93,13 +93,13 @@ namespace glm
 		this->value[2] = col_type(static_cast<T>(x3), value_type(y3));
 	}
 
-	template <typename T, precision P>
-	template <typename V1, typename V2, typename V3>
-	GLM_FUNC_QUALIFIER tmat3x2<T, P>::tmat3x2
+	template<typename T, precision P>
+	template<typename V1, typename V2, typename V3>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, P>::mat
 	(
-		tvec2<V1, P> const & v1,
-		tvec2<V2, P> const & v2,
-		tvec2<V3, P> const & v3
+		vec<2, V1, P> const & v1,
+		vec<2, V2, P> const & v2,
+		vec<2, V3, P> const & v3
 	)
 	{
 		this->value[0] = col_type(v1);
@@ -109,73 +109,73 @@ namespace glm
 
 	// -- Matrix conversions --
 
-	template <typename T, precision P>
-	template <typename U, precision Q>
-	GLM_FUNC_QUALIFIER tmat3x2<T, P>::tmat3x2(tmat3x2<U, Q> const & m)
+	template<typename T, precision P>
+	template<typename U, precision Q>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, P>::mat(mat<3, 2, U, Q> const & m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
 		this->value[2] = col_type(m[2]);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x2<T, P>::tmat3x2(tmat2x2<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, P>::mat(mat<2, 2, T, P> const & m)
 	{
 		this->value[0] = m[0];
 		this->value[1] = m[1];
 		this->value[2] = col_type(0);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x2<T, P>::tmat3x2(tmat3x3<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, P>::mat(mat<3, 3, T, P> const & m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
 		this->value[2] = col_type(m[2]);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x2<T, P>::tmat3x2(tmat4x4<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, P>::mat(mat<4, 4, T, P> const & m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
 		this->value[2] = col_type(m[2]);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x2<T, P>::tmat3x2(tmat2x3<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, P>::mat(mat<2, 3, T, P> const & m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
 		this->value[2] = col_type(T(0));
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x2<T, P>::tmat3x2(tmat2x4<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, P>::mat(mat<2, 4, T, P> const & m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
 		this->value[2] = col_type(T(0));
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x2<T, P>::tmat3x2(tmat3x4<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, P>::mat(mat<3, 4, T, P> const & m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
 		this->value[2] = col_type(m[2]);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x2<T, P>::tmat3x2(tmat4x2<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, P>::mat(mat<4, 2, T, P> const & m)
 	{
 		this->value[0] = m[0];
 		this->value[1] = m[1];
 		this->value[2] = m[2];
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x2<T, P>::tmat3x2(tmat4x3<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, P>::mat(mat<4, 3, T, P> const & m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
@@ -184,15 +184,15 @@ namespace glm
 
 	// -- Accesses --
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER typename tmat3x2<T, P>::col_type & tmat3x2<T, P>::operator[](typename tmat3x2<T, P>::length_type i)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER typename mat<3, 2, T, P>::col_type & mat<3, 2, T, P>::operator[](typename mat<3, 2, T, P>::length_type i)
 	{
 		assert(i < this->length());
 		return this->value[i];
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER typename tmat3x2<T, P>::col_type const & tmat3x2<T, P>::operator[](typename tmat3x2<T, P>::length_type i) const
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER typename mat<3, 2, T, P>::col_type const & mat<3, 2, T, P>::operator[](typename mat<3, 2, T, P>::length_type i) const
 	{
 		assert(i < this->length());
 		return this->value[i];
@@ -201,8 +201,8 @@ namespace glm
 	// -- Unary updatable operators --
 
 #	if !GLM_HAS_DEFAULTED_FUNCTIONS
-		template <typename T, precision P>
-		GLM_FUNC_QUALIFIER tmat3x2<T, P>& tmat3x2<T, P>::operator=(tmat3x2<T, P> const & m)
+		template<typename T, precision P>
+		GLM_FUNC_QUALIFIER mat<3, 2, T, P>& mat<3, 2, T, P>::operator=(mat<3, 2, T, P> const & m)
 		{
 			this->value[0] = m[0];
 			this->value[1] = m[1];
@@ -211,9 +211,9 @@ namespace glm
 		}
 #	endif//!GLM_HAS_DEFAULTED_FUNCTIONS
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat3x2<T, P>& tmat3x2<T, P>::operator=(tmat3x2<U, P> const & m)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, P>& mat<3, 2, T, P>::operator=(mat<3, 2, U, P> const & m)
 	{
 		this->value[0] = m[0];
 		this->value[1] = m[1];
@@ -221,9 +221,9 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat3x2<T, P>& tmat3x2<T, P>::operator+=(U s)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, P>& mat<3, 2, T, P>::operator+=(U s)
 	{
 		this->value[0] += s;
 		this->value[1] += s;
@@ -231,9 +231,9 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat3x2<T, P>& tmat3x2<T, P>::operator+=(tmat3x2<U, P> const & m)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, P>& mat<3, 2, T, P>::operator+=(mat<3, 2, U, P> const & m)
 	{
 		this->value[0] += m[0];
 		this->value[1] += m[1];
@@ -241,9 +241,9 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat3x2<T, P>& tmat3x2<T, P>::operator-=(U s)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, P>& mat<3, 2, T, P>::operator-=(U s)
 	{
 		this->value[0] -= s;
 		this->value[1] -= s;
@@ -251,9 +251,9 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat3x2<T, P>& tmat3x2<T, P>::operator-=(tmat3x2<U, P> const & m)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, P>& mat<3, 2, T, P>::operator-=(mat<3, 2, U, P> const & m)
 	{
 		this->value[0] -= m[0];
 		this->value[1] -= m[1];
@@ -261,9 +261,9 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat3x2<T, P>& tmat3x2<T, P>::operator*=(U s)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, P>& mat<3, 2, T, P>::operator*=(U s)
 	{
 		this->value[0] *= s;
 		this->value[1] *= s;
@@ -271,9 +271,9 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat3x2<T, P> & tmat3x2<T, P>::operator/=(U s)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, P> & mat<3, 2, T, P>::operator/=(U s)
 	{
 		this->value[0] /= s;
 		this->value[1] /= s;
@@ -283,8 +283,8 @@ namespace glm
 
 	// -- Increment and decrement operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x2<T, P>& tmat3x2<T, P>::operator++()
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, P>& mat<3, 2, T, P>::operator++()
 	{
 		++this->value[0];
 		++this->value[1];
@@ -292,8 +292,8 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x2<T, P>& tmat3x2<T, P>::operator--()
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, P>& mat<3, 2, T, P>::operator--()
 	{
 		--this->value[0];
 		--this->value[1];
@@ -301,34 +301,34 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x2<T, P> tmat3x2<T, P>::operator++(int)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, P> mat<3, 2, T, P>::operator++(int)
 	{
-		tmat3x2<T, P> Result(*this);
+		mat<3, 2, T, P> Result(*this);
 		++*this;
 		return Result;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x2<T, P> tmat3x2<T, P>::operator--(int)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, P> mat<3, 2, T, P>::operator--(int)
 	{
-		tmat3x2<T, P> Result(*this);
+		mat<3, 2, T, P> Result(*this);
 		--*this;
 		return Result;
 	}
 
 	// -- Unary arithmetic operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x2<T, P> operator+(tmat3x2<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, P> operator+(mat<3, 2, T, P> const & m)
 	{
 		return m;
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat3x2<T, P> operator-(tmat3x2<T, P> const & m)
+	template<typename T, precision P> 
+	GLM_FUNC_QUALIFIER mat<3, 2, T, P> operator-(mat<3, 2, T, P> const & m)
 	{
-		return tmat3x2<T, P>(
+		return mat<3, 2, T, P>(
 			-m[0],
 			-m[1],
 			-m[2]);
@@ -336,79 +336,79 @@ namespace glm
 
 	// -- Binary arithmetic operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x2<T, P> operator+(tmat3x2<T, P> const & m, T scalar)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, P> operator+(mat<3, 2, T, P> const & m, T scalar)
 	{
-		return tmat3x2<T, P>(
+		return mat<3, 2, T, P>(
 			m[0] + scalar,
 			m[1] + scalar,
 			m[2] + scalar);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x2<T, P> operator+(tmat3x2<T, P> const & m1, tmat3x2<T, P> const & m2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, P> operator+(mat<3, 2, T, P> const & m1, mat<3, 2, T, P> const & m2)
 	{
-		return tmat3x2<T, P>(
+		return mat<3, 2, T, P>(
 			m1[0] + m2[0],
 			m1[1] + m2[1],
 			m1[2] + m2[2]);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x2<T, P> operator-(tmat3x2<T, P> const & m, T scalar)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, P> operator-(mat<3, 2, T, P> const & m, T scalar)
 	{
-		return tmat3x2<T, P>(
+		return mat<3, 2, T, P>(
 			m[0] - scalar,
 			m[1] - scalar,
 			m[2] - scalar);
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat3x2<T, P> operator-(tmat3x2<T, P> const & m1, tmat3x2<T, P> const & m2)
+	template<typename T, precision P> 
+	GLM_FUNC_QUALIFIER mat<3, 2, T, P> operator-(mat<3, 2, T, P> const & m1, mat<3, 2, T, P> const & m2)
 	{
-		return tmat3x2<T, P>(
+		return mat<3, 2, T, P>(
 			m1[0] - m2[0],
 			m1[1] - m2[1],
 			m1[2] - m2[2]);
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat3x2<T, P> operator*(tmat3x2<T, P> const & m, T scalar)
+	template<typename T, precision P> 
+	GLM_FUNC_QUALIFIER mat<3, 2, T, P> operator*(mat<3, 2, T, P> const & m, T scalar)
 	{
-		return tmat3x2<T, P>(
+		return mat<3, 2, T, P>(
 			m[0] * scalar,
 			m[1] * scalar,
 			m[2] * scalar);
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat3x2<T, P> operator*(T scalar, tmat3x2<T, P> const & m)
+	template<typename T, precision P> 
+	GLM_FUNC_QUALIFIER mat<3, 2, T, P> operator*(T scalar, mat<3, 2, T, P> const & m)
 	{
-		return tmat3x2<T, P>(
+		return mat<3, 2, T, P>(
 			m[0] * scalar,
 			m[1] * scalar,
 			m[2] * scalar);
 	}
    
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER typename tmat3x2<T, P>::col_type operator*(tmat3x2<T, P> const & m, typename tmat3x2<T, P>::row_type const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER typename mat<3, 2, T, P>::col_type operator*(mat<3, 2, T, P> const & m, typename mat<3, 2, T, P>::row_type const & v)
 	{
-		return typename tmat3x2<T, P>::col_type(
+		return typename mat<3, 2, T, P>::col_type(
 			m[0][0] * v.x + m[1][0] * v.y + m[2][0] * v.z,
 			m[0][1] * v.x + m[1][1] * v.y + m[2][1] * v.z);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER typename tmat3x2<T, P>::row_type operator*(typename tmat3x2<T, P>::col_type const & v, tmat3x2<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER typename mat<3, 2, T, P>::row_type operator*(typename mat<3, 2, T, P>::col_type const & v, mat<3, 2, T, P> const & m)
 	{
-		return typename tmat3x2<T, P>::row_type(
+		return typename mat<3, 2, T, P>::row_type(
 			v.x * m[0][0] + v.y * m[0][1],
 			v.x * m[1][0] + v.y * m[1][1],
 			v.x * m[2][0] + v.y * m[2][1]);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P> operator*(tmat3x2<T, P> const & m1, tmat2x3<T, P> const & m2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, P> operator*(mat<3, 2, T, P> const & m1, mat<2, 3, T, P> const & m2)
 	{
 		const T SrcA00 = m1[0][0];
 		const T SrcA01 = m1[0][1];
@@ -424,7 +424,7 @@ namespace glm
 		const T SrcB11 = m2[1][1];
 		const T SrcB12 = m2[1][2];
 
-		tmat2x2<T, P> Result(uninitialize);
+		mat<2, 2, T, P> Result(uninitialize);
 		Result[0][0] = SrcA00 * SrcB00 + SrcA10 * SrcB01 + SrcA20 * SrcB02;
 		Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01 + SrcA21 * SrcB02;
 		Result[1][0] = SrcA00 * SrcB10 + SrcA10 * SrcB11 + SrcA20 * SrcB12;
@@ -432,10 +432,10 @@ namespace glm
 		return Result;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x2<T, P> operator*(tmat3x2<T, P> const & m1, tmat3x3<T, P> const & m2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, P> operator*(mat<3, 2, T, P> const & m1, mat<3, 3, T, P> const & m2)
 	{
-		return tmat3x2<T, P>(
+		return mat<3, 2, T, P>(
 			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2],
 			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2],
 			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2],
@@ -444,10 +444,10 @@ namespace glm
 			m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1] + m1[2][1] * m2[2][2]);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x2<T, P> operator*(tmat3x2<T, P> const & m1, tmat4x3<T, P> const & m2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, P> operator*(mat<3, 2, T, P> const & m1, mat<4, 3, T, P> const & m2)
 	{
-		return tmat4x2<T, P>(
+		return mat<4, 2, T, P>(
 			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2],
 			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2],
 			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2],
@@ -458,19 +458,19 @@ namespace glm
 			m1[0][1] * m2[3][0] + m1[1][1] * m2[3][1] + m1[2][1] * m2[3][2]);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x2<T, P> operator/(tmat3x2<T, P> const & m, T scalar)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, P> operator/(mat<3, 2, T, P> const & m, T scalar)
 	{
-		return tmat3x2<T, P>(
+		return mat<3, 2, T, P>(
 			m[0] / scalar,
 			m[1] / scalar,
 			m[2] / scalar);
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat3x2<T, P> operator/(T scalar, tmat3x2<T, P> const & m)
+	template<typename T, precision P> 
+	GLM_FUNC_QUALIFIER mat<3, 2, T, P> operator/(T scalar, mat<3, 2, T, P> const & m)
 	{
-		return tmat3x2<T, P>(
+		return mat<3, 2, T, P>(
 			scalar / m[0],
 			scalar / m[1],
 			scalar / m[2]);
@@ -478,14 +478,14 @@ namespace glm
 
 	// -- Boolean operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER bool operator==(tmat3x2<T, P> const & m1, tmat3x2<T, P> const & m2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER bool operator==(mat<3, 2, T, P> const & m1, mat<3, 2, T, P> const & m2)
 	{
 		return (m1[0] == m2[0]) && (m1[1] == m2[1]) && (m1[2] == m2[2]);
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER bool operator!=(tmat3x2<T, P> const & m1, tmat3x2<T, P> const & m2)
+	template<typename T, precision P> 
+	GLM_FUNC_QUALIFIER bool operator!=(mat<3, 2, T, P> const & m1, mat<3, 2, T, P> const & m2)
 	{
 		return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]);
 	}
diff --git a/glm/detail/type_mat3x3.hpp b/glm/detail/type_mat3x3.hpp
index d5ebe629..1a9f3365 100644
--- a/glm/detail/type_mat3x3.hpp
+++ b/glm/detail/type_mat3x3.hpp
@@ -11,13 +11,13 @@
 
 namespace glm
 {
-	template <typename T, precision P = defaultp>
-	struct tmat3x3
+	template<typename T, precision P>
+	struct mat<3, 3, T, P>
 	{
-		typedef tvec3<T, P> col_type;
-		typedef tvec3<T, P> row_type;
-		typedef tmat3x3<T, P> type;
-		typedef tmat3x3<T, P> transpose_type;
+		typedef vec<3, T, P> col_type;
+		typedef vec<3, T, P> row_type;
+		typedef mat<3, 3, T, P> type;
+		typedef mat<3, 3, T, P> transpose_type;
 		typedef T value_type;
 
 	private:
@@ -26,18 +26,18 @@ namespace glm
 	public:
 		// -- Constructors --
 
-		GLM_FUNC_DECL tmat3x3() GLM_DEFAULT_CTOR;
-		GLM_FUNC_DECL tmat3x3(tmat3x3<T, P> const & m) GLM_DEFAULT;
-		template <precision Q>
-		GLM_FUNC_DECL tmat3x3(tmat3x3<T, Q> const & m);
+		GLM_FUNC_DECL mat() GLM_DEFAULT_CTOR;
+		GLM_FUNC_DECL mat(mat<3, 3, T, P> const & m) GLM_DEFAULT;
+		template<precision Q>
+		GLM_FUNC_DECL mat(mat<3, 3, T, Q> const & m);
 
-		GLM_FUNC_DECL GLM_CONSTEXPR_CTOR explicit tmat3x3(ctor);
-		GLM_FUNC_DECL explicit tmat3x3(T scalar);
-		GLM_FUNC_DECL tmat3x3(
+		GLM_FUNC_DECL GLM_CONSTEXPR_CTOR explicit mat(ctor);
+		GLM_FUNC_DECL explicit mat(T scalar);
+		GLM_FUNC_DECL mat(
 			T x0, T y0, T z0,
 			T x1, T y1, T z1,
 			T x2, T y2, T z2);
-		GLM_FUNC_DECL tmat3x3(
+		GLM_FUNC_DECL mat(
 			col_type const & v0,
 			col_type const & v1,
 			col_type const & v2);
@@ -48,30 +48,30 @@ namespace glm
 			typename X1, typename Y1, typename Z1,
 			typename X2, typename Y2, typename Z2,
 			typename X3, typename Y3, typename Z3>
-		GLM_FUNC_DECL tmat3x3(
+		GLM_FUNC_DECL mat(
 			X1 x1, Y1 y1, Z1 z1,
 			X2 x2, Y2 y2, Z2 z2,
 			X3 x3, Y3 y3, Z3 z3);
 
-		template <typename V1, typename V2, typename V3>
-		GLM_FUNC_DECL tmat3x3(
-			tvec3<V1, P> const & v1,
-			tvec3<V2, P> const & v2,
-			tvec3<V3, P> const & v3);
+		template<typename V1, typename V2, typename V3>
+		GLM_FUNC_DECL mat(
+			vec<3, V1, P> const & v1,
+			vec<3, V2, P> const & v2,
+			vec<3, V3, P> const & v3);
 
 		// -- Matrix conversions --
 
-		template <typename U, precision Q>
-		GLM_FUNC_DECL GLM_EXPLICIT tmat3x3(tmat3x3<U, Q> const & m);
+		template<typename U, precision Q>
+		GLM_FUNC_DECL GLM_EXPLICIT mat(mat<3, 3, U, Q> const & m);
 
-		GLM_FUNC_DECL GLM_EXPLICIT tmat3x3(tmat2x2<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat3x3(tmat4x4<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat3x3(tmat2x3<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat3x3(tmat3x2<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat3x3(tmat2x4<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat3x3(tmat4x2<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat3x3(tmat3x4<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat3x3(tmat4x3<T, P> const & x);
+		GLM_FUNC_DECL GLM_EXPLICIT mat(mat<2, 2, T, P> const & x);
+		GLM_FUNC_DECL GLM_EXPLICIT mat(mat<4, 4, T, P> const & x);
+		GLM_FUNC_DECL GLM_EXPLICIT mat(mat<2, 3, T, P> const & x);
+		GLM_FUNC_DECL GLM_EXPLICIT mat(mat<3, 2, T, P> const & x);
+		GLM_FUNC_DECL GLM_EXPLICIT mat(mat<2, 4, T, P> const & x);
+		GLM_FUNC_DECL GLM_EXPLICIT mat(mat<4, 2, T, P> const & x);
+		GLM_FUNC_DECL GLM_EXPLICIT mat(mat<3, 4, T, P> const & x);
+		GLM_FUNC_DECL GLM_EXPLICIT mat(mat<4, 3, T, P> const & x);
 
 		// -- Accesses --
 
@@ -83,106 +83,106 @@ namespace glm
 
 		// -- Unary arithmetic operators --
 
-		GLM_FUNC_DECL tmat3x3<T, P> & operator=(tmat3x3<T, P> const & m) GLM_DEFAULT;
+		GLM_FUNC_DECL mat<3, 3, T, P> & operator=(mat<3, 3, T, P> const & m) GLM_DEFAULT;
 
-		template <typename U>
-		GLM_FUNC_DECL tmat3x3<T, P> & operator=(tmat3x3<U, P> const & m);
-		template <typename U>
-		GLM_FUNC_DECL tmat3x3<T, P> & operator+=(U s);
-		template <typename U>
-		GLM_FUNC_DECL tmat3x3<T, P> & operator+=(tmat3x3<U, P> const & m);
-		template <typename U>
-		GLM_FUNC_DECL tmat3x3<T, P> & operator-=(U s);
-		template <typename U>
-		GLM_FUNC_DECL tmat3x3<T, P> & operator-=(tmat3x3<U, P> const & m);
-		template <typename U>
-		GLM_FUNC_DECL tmat3x3<T, P> & operator*=(U s);
-		template <typename U>
-		GLM_FUNC_DECL tmat3x3<T, P> & operator*=(tmat3x3<U, P> const & m);
-		template <typename U>
-		GLM_FUNC_DECL tmat3x3<T, P> & operator/=(U s);
-		template <typename U>
-		GLM_FUNC_DECL tmat3x3<T, P> & operator/=(tmat3x3<U, P> const & m);
+		template<typename U>
+		GLM_FUNC_DECL mat<3, 3, T, P> & operator=(mat<3, 3, U, P> const & m);
+		template<typename U>
+		GLM_FUNC_DECL mat<3, 3, T, P> & operator+=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<3, 3, T, P> & operator+=(mat<3, 3, U, P> const & m);
+		template<typename U>
+		GLM_FUNC_DECL mat<3, 3, T, P> & operator-=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<3, 3, T, P> & operator-=(mat<3, 3, U, P> const & m);
+		template<typename U>
+		GLM_FUNC_DECL mat<3, 3, T, P> & operator*=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<3, 3, T, P> & operator*=(mat<3, 3, U, P> const & m);
+		template<typename U>
+		GLM_FUNC_DECL mat<3, 3, T, P> & operator/=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<3, 3, T, P> & operator/=(mat<3, 3, U, P> const & m);
 
 		// -- Increment and decrement operators --
 
-		GLM_FUNC_DECL tmat3x3<T, P> & operator++();
-		GLM_FUNC_DECL tmat3x3<T, P> & operator--();
-		GLM_FUNC_DECL tmat3x3<T, P> operator++(int);
-		GLM_FUNC_DECL tmat3x3<T, P> operator--(int);
+		GLM_FUNC_DECL mat<3, 3, T, P> & operator++();
+		GLM_FUNC_DECL mat<3, 3, T, P> & operator--();
+		GLM_FUNC_DECL mat<3, 3, T, P> operator++(int);
+		GLM_FUNC_DECL mat<3, 3, T, P> operator--(int);
 	};
 
 	// -- Unary operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat3x3<T, P> operator+(tmat3x3<T, P> const & m);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<3, 3, T, P> operator+(mat<3, 3, T, P> const & m);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat3x3<T, P> operator-(tmat3x3<T, P> const & m);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<3, 3, T, P> operator-(mat<3, 3, T, P> const & m);
 
 	// -- Binary operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat3x3<T, P> operator+(tmat3x3<T, P> const & m, T scalar);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<3, 3, T, P> operator+(mat<3, 3, T, P> const & m, T scalar);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat3x3<T, P> operator+(T scalar, tmat3x3<T, P> const & m);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<3, 3, T, P> operator+(T scalar, mat<3, 3, T, P> const & m);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat3x3<T, P> operator+(tmat3x3<T, P> const & m1, tmat3x3<T, P> const & m2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<3, 3, T, P> operator+(mat<3, 3, T, P> const & m1, mat<3, 3, T, P> const & m2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat3x3<T, P> operator-(tmat3x3<T, P> const & m, T scalar);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<3, 3, T, P> operator-(mat<3, 3, T, P> const & m, T scalar);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat3x3<T, P> operator-(T scalar, tmat3x3<T, P> const & m);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<3, 3, T, P> operator-(T scalar, mat<3, 3, T, P> const & m);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat3x3<T, P> operator-(tmat3x3<T, P> const & m1, tmat3x3<T, P> const & m2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<3, 3, T, P> operator-(mat<3, 3, T, P> const & m1, mat<3, 3, T, P> const & m2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat3x3<T, P> operator*(tmat3x3<T, P> const & m, T scalar);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<3, 3, T, P> operator*(mat<3, 3, T, P> const & m, T scalar);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat3x3<T, P> operator*(T scalar, tmat3x3<T, P> const & m);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<3, 3, T, P> operator*(T scalar, mat<3, 3, T, P> const & m);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL typename tmat3x3<T, P>::col_type operator*(tmat3x3<T, P> const & m, typename tmat3x3<T, P>::row_type const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL typename mat<3, 3, T, P>::col_type operator*(mat<3, 3, T, P> const & m, typename mat<3, 3, T, P>::row_type const & v);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL typename tmat3x3<T, P>::row_type operator*(typename tmat3x3<T, P>::col_type const & v, tmat3x3<T, P> const & m);
+	template<typename T, precision P>
+	GLM_FUNC_DECL typename mat<3, 3, T, P>::row_type operator*(typename mat<3, 3, T, P>::col_type const & v, mat<3, 3, T, P> const & m);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat3x3<T, P> operator*(tmat3x3<T, P> const & m1, tmat3x3<T, P> const & m2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<3, 3, T, P> operator*(mat<3, 3, T, P> const & m1, mat<3, 3, T, P> const & m2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x3<T, P> operator*(tmat3x3<T, P> const & m1, tmat2x3<T, P> const & m2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<2, 3, T, P> operator*(mat<3, 3, T, P> const & m1, mat<2, 3, T, P> const & m2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat4x3<T, P> operator*(tmat3x3<T, P> const & m1, tmat4x3<T, P> const & m2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<4, 3, T, P> operator*(mat<3, 3, T, P> const & m1, mat<4, 3, T, P> const & m2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat3x3<T, P> operator/(tmat3x3<T, P> const & m, T scalar);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<3, 3, T, P> operator/(mat<3, 3, T, P> const & m, T scalar);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat3x3<T, P> operator/(T scalar, tmat3x3<T, P> const & m);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<3, 3, T, P> operator/(T scalar, mat<3, 3, T, P> const & m);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL typename tmat3x3<T, P>::col_type operator/(tmat3x3<T, P> const & m, typename tmat3x3<T, P>::row_type const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL typename mat<3, 3, T, P>::col_type operator/(mat<3, 3, T, P> const & m, typename mat<3, 3, T, P>::row_type const & v);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL typename tmat3x3<T, P>::row_type operator/(typename tmat3x3<T, P>::col_type const & v, tmat3x3<T, P> const & m);
+	template<typename T, precision P>
+	GLM_FUNC_DECL typename mat<3, 3, T, P>::row_type operator/(typename mat<3, 3, T, P>::col_type const & v, mat<3, 3, T, P> const & m);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat3x3<T, P> operator/(tmat3x3<T, P> const & m1, tmat3x3<T, P> const & m2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<3, 3, T, P> operator/(mat<3, 3, T, P> const & m1, mat<3, 3, T, P> const & m2);
 
 	// -- Boolean operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL bool operator==(tmat3x3<T, P> const & m1, tmat3x3<T, P> const & m2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL bool operator==(mat<3, 3, T, P> const & m1, mat<3, 3, T, P> const & m2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL bool operator!=(tmat3x3<T, P> const & m1, tmat3x3<T, P> const & m2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL bool operator!=(mat<3, 3, T, P> const & m1, mat<3, 3, T, P> const & m2);
 }//namespace glm
 
 #ifndef GLM_EXTERNAL_TEMPLATE
diff --git a/glm/detail/type_mat3x3.inl b/glm/detail/type_mat3x3.inl
index 324cca32..f4b4ad8e 100644
--- a/glm/detail/type_mat3x3.inl
+++ b/glm/detail/type_mat3x3.inl
@@ -8,8 +8,8 @@ namespace glm
 	// -- Constructors --
 
 #	if !GLM_HAS_DEFAULTED_FUNCTIONS || !defined(GLM_FORCE_NO_CTOR_INIT)
-		template <typename T, precision P>
-		GLM_FUNC_QUALIFIER tmat3x3<T, P>::tmat3x3()
+		template<typename T, precision P>
+		GLM_FUNC_QUALIFIER mat<3, 3, T, P>::mat()
 		{
 #			ifndef GLM_FORCE_NO_CTOR_INIT 
 				this->value[0] = col_type(1, 0, 0);
@@ -20,8 +20,8 @@ namespace glm
 #	endif
 
 #	if !GLM_HAS_DEFAULTED_FUNCTIONS
-		template <typename T, precision P>
-		GLM_FUNC_QUALIFIER tmat3x3<T, P>::tmat3x3(tmat3x3<T, P> const & m)
+		template<typename T, precision P>
+		GLM_FUNC_QUALIFIER mat<3, 3, T, P>::mat(mat<3, 3, T, P> const & m)
 		{
 			this->value[0] = m.value[0];
 			this->value[1] = m.value[1];
@@ -29,29 +29,29 @@ namespace glm
 		}
 #	endif//!GLM_HAS_DEFAULTED_FUNCTIONS
 
-	template <typename T, precision P>
-	template <precision Q>
-	GLM_FUNC_QUALIFIER tmat3x3<T, P>::tmat3x3(tmat3x3<T, Q> const & m)
+	template<typename T, precision P>
+	template<precision Q>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, P>::mat(mat<3, 3, T, Q> const & m)
 	{
 		this->value[0] = m.value[0];
 		this->value[1] = m.value[1];
 		this->value[2] = m.value[2];
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR tmat3x3<T, P>::tmat3x3(ctor)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR mat<3, 3, T, P>::mat(ctor)
 	{}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x3<T, P>::tmat3x3(T scalar)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, P>::mat(T scalar)
 	{
 		this->value[0] = col_type(scalar, 0, 0);
 		this->value[1] = col_type(0, scalar, 0);
 		this->value[2] = col_type(0, 0, scalar);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x3<T, P>::tmat3x3
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, P>::mat
 	(
 		T x0, T y0, T z0,
 		T x1, T y1, T z1,
@@ -63,8 +63,8 @@ namespace glm
 		this->value[2] = col_type(x2, y2, z2);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x3<T, P>::tmat3x3
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, P>::mat
 	(
 		col_type const & v0,
 		col_type const & v1,
@@ -78,12 +78,12 @@ namespace glm
 
 	// -- Conversion constructors --
 
-	template <typename T, precision P>
-	template <
+	template<typename T, precision P>
+	template<
 		typename X1, typename Y1, typename Z1,
 		typename X2, typename Y2, typename Z2,
 		typename X3, typename Y3, typename Z3>
-	GLM_FUNC_QUALIFIER tmat3x3<T, P>::tmat3x3
+	GLM_FUNC_QUALIFIER mat<3, 3, T, P>::mat
 	(
 		X1 x1, Y1 y1, Z1 z1,
 		X2 x2, Y2 y2, Z2 z2,
@@ -95,13 +95,13 @@ namespace glm
 		this->value[2] = col_type(static_cast<T>(x3), value_type(y3), value_type(z3));
 	}
 	
-	template <typename T, precision P>
-	template <typename V1, typename V2, typename V3>
-	GLM_FUNC_QUALIFIER tmat3x3<T, P>::tmat3x3
+	template<typename T, precision P>
+	template<typename V1, typename V2, typename V3>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, P>::mat
 	(
-		tvec3<V1, P> const & v1,
-		tvec3<V2, P> const & v2,
-		tvec3<V3, P> const & v3
+		vec<3, V1, P> const& v1,
+		vec<3, V2, P> const& v2,
+		vec<3, V3, P> const& v3
 	)
 	{
 		this->value[0] = col_type(v1);
@@ -111,73 +111,73 @@ namespace glm
 
 	// -- Matrix conversions --
 
-	template <typename T, precision P>
-	template <typename U, precision Q>
-	GLM_FUNC_QUALIFIER tmat3x3<T, P>::tmat3x3(tmat3x3<U, Q> const & m)
+	template<typename T, precision P>
+	template<typename U, precision Q>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, P>::mat(mat<3, 3, U, Q> const & m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
 		this->value[2] = col_type(m[2]);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x3<T, P>::tmat3x3(tmat2x2<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, P>::mat(mat<2, 2, T, P> const & m)
 	{
 		this->value[0] = col_type(m[0], 0);
 		this->value[1] = col_type(m[1], 0);
 		this->value[2] = col_type(0, 0, 1);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x3<T, P>::tmat3x3(tmat4x4<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, P>::mat(mat<4, 4, T, P> const & m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
 		this->value[2] = col_type(m[2]);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x3<T, P>::tmat3x3(tmat2x3<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, P>::mat(mat<2, 3, T, P> const & m)
 	{
 		this->value[0] = m[0];
 		this->value[1] = m[1];
 		this->value[2] = col_type(0, 0, 1);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x3<T, P>::tmat3x3(tmat3x2<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, P>::mat(mat<3, 2, T, P> const & m)
 	{
 		this->value[0] = col_type(m[0], 0);
 		this->value[1] = col_type(m[1], 0);
 		this->value[2] = col_type(m[2], 1);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x3<T, P>::tmat3x3(tmat2x4<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, P>::mat(mat<2, 4, T, P> const & m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
 		this->value[2] = col_type(0, 0, 1);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x3<T, P>::tmat3x3(tmat4x2<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, P>::mat(mat<4, 2, T, P> const & m)
 	{
 		this->value[0] = col_type(m[0], 0);
 		this->value[1] = col_type(m[1], 0);
 		this->value[2] = col_type(m[2], 1);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x3<T, P>::tmat3x3(tmat3x4<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, P>::mat(mat<3, 4, T, P> const & m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
 		this->value[2] = col_type(m[2]);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x3<T, P>::tmat3x3(tmat4x3<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, P>::mat(mat<4, 3, T, P> const & m)
 	{
 		this->value[0] = m[0];
 		this->value[1] = m[1];
@@ -186,15 +186,15 @@ namespace glm
 
 	// -- Accesses --
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER typename tmat3x3<T, P>::col_type & tmat3x3<T, P>::operator[](typename tmat3x3<T, P>::length_type i)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER typename mat<3, 3, T, P>::col_type & mat<3, 3, T, P>::operator[](typename mat<3, 3, T, P>::length_type i)
 	{
 		assert(i < this->length());
 		return this->value[i];
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER typename tmat3x3<T, P>::col_type const & tmat3x3<T, P>::operator[](typename tmat3x3<T, P>::length_type i) const
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER typename mat<3, 3, T, P>::col_type const & mat<3, 3, T, P>::operator[](typename mat<3, 3, T, P>::length_type i) const
 	{
 		assert(i < this->length());
 		return this->value[i];
@@ -203,8 +203,8 @@ namespace glm
 	// -- Unary updatable operators --
 
 #	if !GLM_HAS_DEFAULTED_FUNCTIONS
-		template <typename T, precision P>
-		GLM_FUNC_QUALIFIER tmat3x3<T, P> & tmat3x3<T, P>::operator=(tmat3x3<T, P> const & m)
+		template<typename T, precision P>
+		GLM_FUNC_QUALIFIER mat<3, 3, T, P> & mat<3, 3, T, P>::operator=(mat<3, 3, T, P> const & m)
 		{
 			this->value[0] = m[0];
 			this->value[1] = m[1];
@@ -213,9 +213,9 @@ namespace glm
 		}
 #	endif//!GLM_HAS_DEFAULTED_FUNCTIONS
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat3x3<T, P> & tmat3x3<T, P>::operator=(tmat3x3<U, P> const & m)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, P> & mat<3, 3, T, P>::operator=(mat<3, 3, U, P> const & m)
 	{
 		this->value[0] = m[0];
 		this->value[1] = m[1];
@@ -223,9 +223,9 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat3x3<T, P> & tmat3x3<T, P>::operator+=(U s)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, P> & mat<3, 3, T, P>::operator+=(U s)
 	{
 		this->value[0] += s;
 		this->value[1] += s;
@@ -233,9 +233,9 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat3x3<T, P> & tmat3x3<T, P>::operator+=(tmat3x3<U, P> const & m)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, P> & mat<3, 3, T, P>::operator+=(mat<3, 3, U, P> const & m)
 	{
 		this->value[0] += m[0];
 		this->value[1] += m[1];
@@ -243,9 +243,9 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat3x3<T, P> & tmat3x3<T, P>::operator-=(U s)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, P> & mat<3, 3, T, P>::operator-=(U s)
 	{
 		this->value[0] -= s;
 		this->value[1] -= s;
@@ -253,9 +253,9 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat3x3<T, P> & tmat3x3<T, P>::operator-=(tmat3x3<U, P> const & m)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, P> & mat<3, 3, T, P>::operator-=(mat<3, 3, U, P> const & m)
 	{
 		this->value[0] -= m[0];
 		this->value[1] -= m[1];
@@ -263,9 +263,9 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat3x3<T, P> & tmat3x3<T, P>::operator*=(U s)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, P> & mat<3, 3, T, P>::operator*=(U s)
 	{
 		this->value[0] *= s;
 		this->value[1] *= s;
@@ -273,16 +273,16 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat3x3<T, P> & tmat3x3<T, P>::operator*=(tmat3x3<U, P> const & m)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, P> & mat<3, 3, T, P>::operator*=(mat<3, 3, U, P> const & m)
 	{
 		return (*this = *this * m);
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat3x3<T, P> & tmat3x3<T, P>::operator/=(U s)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, P> & mat<3, 3, T, P>::operator/=(U s)
 	{
 		this->value[0] /= s;
 		this->value[1] /= s;
@@ -290,17 +290,17 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat3x3<T, P> & tmat3x3<T, P>::operator/=(tmat3x3<U, P> const & m)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, P> & mat<3, 3, T, P>::operator/=(mat<3, 3, U, P> const & m)
 	{
 		return *this *= inverse(m);
 	}
 
 	// -- Increment and decrement operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x3<T, P> & tmat3x3<T, P>::operator++()
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, P> & mat<3, 3, T, P>::operator++()
 	{
 		++this->value[0];
 		++this->value[1];
@@ -308,8 +308,8 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x3<T, P> & tmat3x3<T, P>::operator--()
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, P> & mat<3, 3, T, P>::operator--()
 	{
 		--this->value[0];
 		--this->value[1];
@@ -317,34 +317,34 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x3<T, P> tmat3x3<T, P>::operator++(int)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, P> mat<3, 3, T, P>::operator++(int)
 	{
-		tmat3x3<T, P> Result(*this);
+		mat<3, 3, T, P> Result(*this);
 		++*this;
 		return Result;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x3<T, P> tmat3x3<T, P>::operator--(int)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, P> mat<3, 3, T, P>::operator--(int)
 	{
-		tmat3x3<T, P> Result(*this);
+		mat<3, 3, T, P> Result(*this);
 		--*this;
 		return Result;
 	}
 
 	// -- Unary arithmetic operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x3<T, P> operator+(tmat3x3<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, P> operator+(mat<3, 3, T, P> const & m)
 	{
 		return m;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x3<T, P> operator-(tmat3x3<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, P> operator-(mat<3, 3, T, P> const & m)
 	{
-		return tmat3x3<T, P>(
+		return mat<3, 3, T, P>(
 			-m[0], 
 			-m[1],
 			-m[2]);
@@ -352,98 +352,98 @@ namespace glm
 
 	// -- Binary arithmetic operators --
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat3x3<T, P> operator+(tmat3x3<T, P> const & m, T scalar)
+	template<typename T, precision P> 
+	GLM_FUNC_QUALIFIER mat<3, 3, T, P> operator+(mat<3, 3, T, P> const & m, T scalar)
 	{
-		return tmat3x3<T, P>(
+		return mat<3, 3, T, P>(
 			m[0] + scalar,
 			m[1] + scalar,
 			m[2] + scalar);
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat3x3<T, P> operator+(T scalar, tmat3x3<T, P> const & m)
+	template<typename T, precision P> 
+	GLM_FUNC_QUALIFIER mat<3, 3, T, P> operator+(T scalar, mat<3, 3, T, P> const & m)
 	{
-		return tmat3x3<T, P>(
+		return mat<3, 3, T, P>(
 			m[0] + scalar,
 			m[1] + scalar,
 			m[2] + scalar);
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat3x3<T, P> operator+(tmat3x3<T, P> const & m1, tmat3x3<T, P> const & m2)
+	template<typename T, precision P> 
+	GLM_FUNC_QUALIFIER mat<3, 3, T, P> operator+(mat<3, 3, T, P> const & m1, mat<3, 3, T, P> const & m2)
 	{
-		return tmat3x3<T, P>(
+		return mat<3, 3, T, P>(
 			m1[0] + m2[0],
 			m1[1] + m2[1],
 			m1[2] + m2[2]);
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat3x3<T, P> operator-(tmat3x3<T, P> const & m, T scalar)
+	template<typename T, precision P> 
+	GLM_FUNC_QUALIFIER mat<3, 3, T, P> operator-(mat<3, 3, T, P> const & m, T scalar)
 	{
-		return tmat3x3<T, P>(
+		return mat<3, 3, T, P>(
 			m[0] - scalar,
 			m[1] - scalar,
 			m[2] - scalar);
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat3x3<T, P> operator-(T scalar, tmat3x3<T, P> const & m)
+	template<typename T, precision P> 
+	GLM_FUNC_QUALIFIER mat<3, 3, T, P> operator-(T scalar, mat<3, 3, T, P> const & m)
 	{
-		return tmat3x3<T, P>(
+		return mat<3, 3, T, P>(
 			scalar - m[0],
 			scalar - m[1],
 			scalar - m[2]);
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat3x3<T, P> operator-(tmat3x3<T, P> const & m1, tmat3x3<T, P> const & m2)
+	template<typename T, precision P> 
+	GLM_FUNC_QUALIFIER mat<3, 3, T, P> operator-(mat<3, 3, T, P> const & m1, mat<3, 3, T, P> const & m2)
 	{
-		return tmat3x3<T, P>(
+		return mat<3, 3, T, P>(
 			m1[0] - m2[0],
 			m1[1] - m2[1],
 			m1[2] - m2[2]);
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat3x3<T, P> operator*(tmat3x3<T, P> const & m, T scalar)
+	template<typename T, precision P> 
+	GLM_FUNC_QUALIFIER mat<3, 3, T, P> operator*(mat<3, 3, T, P> const & m, T scalar)
 	{
-		return tmat3x3<T, P>(
+		return mat<3, 3, T, P>(
 			m[0] * scalar,
 			m[1] * scalar,
 			m[2] * scalar);
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat3x3<T, P> operator*(T scalar, tmat3x3<T, P> const & m)
+	template<typename T, precision P> 
+	GLM_FUNC_QUALIFIER mat<3, 3, T, P> operator*(T scalar, mat<3, 3, T, P> const & m)
 	{
-		return tmat3x3<T, P>(
+		return mat<3, 3, T, P>(
 			m[0] * scalar,
 			m[1] * scalar,
 			m[2] * scalar);
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER typename tmat3x3<T, P>::col_type operator*(tmat3x3<T, P> const & m, typename tmat3x3<T, P>::row_type const & v)
+	template<typename T, precision P> 
+	GLM_FUNC_QUALIFIER typename mat<3, 3, T, P>::col_type operator*(mat<3, 3, T, P> const & m, typename mat<3, 3, T, P>::row_type const & v)
 	{
-		return typename tmat3x3<T, P>::col_type(
+		return typename mat<3, 3, T, P>::col_type(
 			m[0][0] * v.x + m[1][0] * v.y + m[2][0] * v.z,
 			m[0][1] * v.x + m[1][1] * v.y + m[2][1] * v.z,
 			m[0][2] * v.x + m[1][2] * v.y + m[2][2] * v.z);
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER typename tmat3x3<T, P>::row_type operator*(typename tmat3x3<T, P>::col_type const & v, tmat3x3<T, P> const & m)
+	template<typename T, precision P> 
+	GLM_FUNC_QUALIFIER typename mat<3, 3, T, P>::row_type operator*(typename mat<3, 3, T, P>::col_type const & v, mat<3, 3, T, P> const & m)
 	{
-		return typename tmat3x3<T, P>::row_type(
+		return typename mat<3, 3, T, P>::row_type(
 			m[0][0] * v.x + m[0][1] * v.y + m[0][2] * v.z,
 			m[1][0] * v.x + m[1][1] * v.y + m[1][2] * v.z,
 			m[2][0] * v.x + m[2][1] * v.y + m[2][2] * v.z);
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat3x3<T, P> operator*(tmat3x3<T, P> const & m1, tmat3x3<T, P> const & m2)
+	template<typename T, precision P> 
+	GLM_FUNC_QUALIFIER mat<3, 3, T, P> operator*(mat<3, 3, T, P> const & m1, mat<3, 3, T, P> const & m2)
 	{
 		T const SrcA00 = m1[0][0];
 		T const SrcA01 = m1[0][1];
@@ -465,7 +465,7 @@ namespace glm
 		T const SrcB21 = m2[2][1];
 		T const SrcB22 = m2[2][2];
 
-		tmat3x3<T, P> Result(uninitialize);
+		mat<3, 3, T, P> Result(uninitialize);
 		Result[0][0] = SrcA00 * SrcB00 + SrcA10 * SrcB01 + SrcA20 * SrcB02;
 		Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01 + SrcA21 * SrcB02;
 		Result[0][2] = SrcA02 * SrcB00 + SrcA12 * SrcB01 + SrcA22 * SrcB02;
@@ -478,10 +478,10 @@ namespace glm
 		return Result;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x3<T, P> operator*(tmat3x3<T, P> const & m1, tmat2x3<T, P> const & m2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<2, 3, T, P> operator*(mat<3, 3, T, P> const & m1, mat<2, 3, T, P> const & m2)
 	{
-		return tmat2x3<T, P>(
+		return mat<2, 3, T, P>(
 			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2],
 			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2],
 			m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1] + m1[2][2] * m2[0][2],
@@ -490,10 +490,10 @@ namespace glm
 			m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1] + m1[2][2] * m2[1][2]);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x3<T, P> operator*(tmat3x3<T, P> const & m1, tmat4x3<T, P> const & m2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, P> operator*(mat<3, 3, T, P> const & m1, mat<4, 3, T, P> const & m2)
 	{
-		return tmat4x3<T, P>(
+		return mat<4, 3, T, P>(
 			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2],
 			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2],
 			m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1] + m1[2][2] * m2[0][2],
@@ -508,53 +508,53 @@ namespace glm
 			m1[0][2] * m2[3][0] + m1[1][2] * m2[3][1] + m1[2][2] * m2[3][2]);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x3<T, P> operator/(tmat3x3<T, P> const & m,	T scalar)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, P> operator/(mat<3, 3, T, P> const & m,	T scalar)
 	{
-		return tmat3x3<T, P>(
+		return mat<3, 3, T, P>(
 			m[0] / scalar,
 			m[1] / scalar,
 			m[2] / scalar);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x3<T, P> operator/(T scalar, tmat3x3<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, P> operator/(T scalar, mat<3, 3, T, P> const & m)
 	{
-		return tmat3x3<T, P>(
+		return mat<3, 3, T, P>(
 			scalar / m[0],
 			scalar / m[1],
 			scalar / m[2]);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER typename tmat3x3<T, P>::col_type operator/(tmat3x3<T, P> const & m, typename tmat3x3<T, P>::row_type const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER typename mat<3, 3, T, P>::col_type operator/(mat<3, 3, T, P> const & m, typename mat<3, 3, T, P>::row_type const & v)
 	{
 		return  inverse(m) * v;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER typename tmat3x3<T, P>::row_type operator/(typename tmat3x3<T, P>::col_type const & v, tmat3x3<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER typename mat<3, 3, T, P>::row_type operator/(typename mat<3, 3, T, P>::col_type const & v, mat<3, 3, T, P> const & m)
 	{
 		return v * inverse(m);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x3<T, P> operator/(tmat3x3<T, P> const & m1, tmat3x3<T, P> const & m2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, P> operator/(mat<3, 3, T, P> const & m1, mat<3, 3, T, P> const & m2)
 	{
-		tmat3x3<T, P> m1_copy(m1);
+		mat<3, 3, T, P> m1_copy(m1);
 		return m1_copy /= m2;
 	}
 
 	// -- Boolean operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER bool operator==(tmat3x3<T, P> const & m1, tmat3x3<T, P> const & m2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER bool operator==(mat<3, 3, T, P> const & m1, mat<3, 3, T, P> const & m2)
 	{
 		return (m1[0] == m2[0]) && (m1[1] == m2[1]) && (m1[2] == m2[2]);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER bool operator!=(tmat3x3<T, P> const & m1, tmat3x3<T, P> const & m2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER bool operator!=(mat<3, 3, T, P> const & m1, mat<3, 3, T, P> const & m2)
 	{
 		return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]);
 	}
diff --git a/glm/detail/type_mat3x4.hpp b/glm/detail/type_mat3x4.hpp
index c5bb9a9b..77d2143e 100644
--- a/glm/detail/type_mat3x4.hpp
+++ b/glm/detail/type_mat3x4.hpp
@@ -12,13 +12,13 @@
 
 namespace glm
 {
-	template <typename T, precision P = defaultp>
-	struct tmat3x4
+	template<typename T, precision P>
+	struct mat<3, 4, T, P>
 	{
-		typedef tvec4<T, P> col_type;
-		typedef tvec3<T, P> row_type;
-		typedef tmat3x4<T, P> type;
-		typedef tmat4x3<T, P> transpose_type;
+		typedef vec<4, T, P> col_type;
+		typedef vec<3, T, P> row_type;
+		typedef mat<3, 4, T, P> type;
+		typedef mat<4, 3, T, P> transpose_type;
 		typedef T value_type;
 
 	private:
@@ -27,18 +27,18 @@ namespace glm
 	public:
 		// -- Constructors --
 
-		GLM_FUNC_DECL tmat3x4() GLM_DEFAULT_CTOR;
-		GLM_FUNC_DECL tmat3x4(tmat3x4<T, P> const & m) GLM_DEFAULT;
-		template <precision Q>
-		GLM_FUNC_DECL tmat3x4(tmat3x4<T, Q> const & m);
+		GLM_FUNC_DECL mat() GLM_DEFAULT_CTOR;
+		GLM_FUNC_DECL mat(mat<3, 4, T, P> const & m) GLM_DEFAULT;
+		template<precision Q>
+		GLM_FUNC_DECL mat(mat<3, 4, T, Q> const & m);
 
-		GLM_FUNC_DECL GLM_CONSTEXPR_CTOR explicit tmat3x4(ctor);
-		GLM_FUNC_DECL explicit tmat3x4(T scalar);
-		GLM_FUNC_DECL tmat3x4(
+		GLM_FUNC_DECL GLM_CONSTEXPR_CTOR explicit mat(ctor);
+		GLM_FUNC_DECL explicit mat(T scalar);
+		GLM_FUNC_DECL mat(
 			T x0, T y0, T z0, T w0,
 			T x1, T y1, T z1, T w1,
 			T x2, T y2, T z2, T w2);
-		GLM_FUNC_DECL tmat3x4(
+		GLM_FUNC_DECL mat(
 			col_type const & v0,
 			col_type const & v1,
 			col_type const & v2);
@@ -49,30 +49,30 @@ namespace glm
 			typename X1, typename Y1, typename Z1, typename W1,
 			typename X2, typename Y2, typename Z2, typename W2,
 			typename X3, typename Y3, typename Z3, typename W3>
-		GLM_FUNC_DECL tmat3x4(
+		GLM_FUNC_DECL mat(
 			X1 x1, Y1 y1, Z1 z1, W1 w1,
 			X2 x2, Y2 y2, Z2 z2, W2 w2,
 			X3 x3, Y3 y3, Z3 z3, W3 w3);
 
-		template <typename V1, typename V2, typename V3>
-		GLM_FUNC_DECL tmat3x4(
-			tvec4<V1, P> const & v1,
-			tvec4<V2, P> const & v2,
-			tvec4<V3, P> const & v3);
+		template<typename V1, typename V2, typename V3>
+		GLM_FUNC_DECL mat(
+			vec<4, V1, P> const & v1,
+			vec<4, V2, P> const & v2,
+			vec<4, V3, P> const & v3);
 
 		// -- Matrix conversions --
 
-		template <typename U, precision Q>
-		GLM_FUNC_DECL GLM_EXPLICIT tmat3x4(tmat3x4<U, Q> const & m);
+		template<typename U, precision Q>
+		GLM_FUNC_DECL GLM_EXPLICIT mat(mat<3, 4, U, Q> const & m);
 
-		GLM_FUNC_DECL GLM_EXPLICIT tmat3x4(tmat2x2<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat3x4(tmat3x3<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat3x4(tmat4x4<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat3x4(tmat2x3<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat3x4(tmat3x2<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat3x4(tmat2x4<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat3x4(tmat4x2<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat3x4(tmat4x3<T, P> const & x);
+		GLM_FUNC_DECL GLM_EXPLICIT mat(mat<2, 2, T, P> const & x);
+		GLM_FUNC_DECL GLM_EXPLICIT mat(mat<3, 3, T, P> const & x);
+		GLM_FUNC_DECL GLM_EXPLICIT mat(mat<4, 4, T, P> const & x);
+		GLM_FUNC_DECL GLM_EXPLICIT mat(mat<2, 3, T, P> const & x);
+		GLM_FUNC_DECL GLM_EXPLICIT mat(mat<3, 2, T, P> const & x);
+		GLM_FUNC_DECL GLM_EXPLICIT mat(mat<2, 4, T, P> const & x);
+		GLM_FUNC_DECL GLM_EXPLICIT mat(mat<4, 2, T, P> const & x);
+		GLM_FUNC_DECL GLM_EXPLICIT mat(mat<4, 3, T, P> const & x);
 
 		// -- Accesses --
 
@@ -84,87 +84,87 @@ namespace glm
 
 		// -- Unary arithmetic operators --
 
-		GLM_FUNC_DECL tmat3x4<T, P> & operator=(tmat3x4<T, P> const & m) GLM_DEFAULT;
+		GLM_FUNC_DECL mat<3, 4, T, P> & operator=(mat<3, 4, T, P> const & m) GLM_DEFAULT;
 
-		template <typename U>
-		GLM_FUNC_DECL tmat3x4<T, P> & operator=(tmat3x4<U, P> const & m);
-		template <typename U>
-		GLM_FUNC_DECL tmat3x4<T, P> & operator+=(U s);
-		template <typename U>
-		GLM_FUNC_DECL tmat3x4<T, P> & operator+=(tmat3x4<U, P> const & m);
-		template <typename U>
-		GLM_FUNC_DECL tmat3x4<T, P> & operator-=(U s);
-		template <typename U>
-		GLM_FUNC_DECL tmat3x4<T, P> & operator-=(tmat3x4<U, P> const & m);
-		template <typename U>
-		GLM_FUNC_DECL tmat3x4<T, P> & operator*=(U s);
-		template <typename U>
-		GLM_FUNC_DECL tmat3x4<T, P> & operator/=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<3, 4, T, P> & operator=(mat<3, 4, U, P> const & m);
+		template<typename U>
+		GLM_FUNC_DECL mat<3, 4, T, P> & operator+=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<3, 4, T, P> & operator+=(mat<3, 4, U, P> const & m);
+		template<typename U>
+		GLM_FUNC_DECL mat<3, 4, T, P> & operator-=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<3, 4, T, P> & operator-=(mat<3, 4, U, P> const & m);
+		template<typename U>
+		GLM_FUNC_DECL mat<3, 4, T, P> & operator*=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<3, 4, T, P> & operator/=(U s);
 
 		// -- Increment and decrement operators --
 
-		GLM_FUNC_DECL tmat3x4<T, P> & operator++();
-		GLM_FUNC_DECL tmat3x4<T, P> & operator--();
-		GLM_FUNC_DECL tmat3x4<T, P> operator++(int);
-		GLM_FUNC_DECL tmat3x4<T, P> operator--(int);
+		GLM_FUNC_DECL mat<3, 4, T, P> & operator++();
+		GLM_FUNC_DECL mat<3, 4, T, P> & operator--();
+		GLM_FUNC_DECL mat<3, 4, T, P> operator++(int);
+		GLM_FUNC_DECL mat<3, 4, T, P> operator--(int);
 	};
 
 	// -- Unary operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat3x4<T, P> operator+(tmat3x4<T, P> const & m);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<3, 4, T, P> operator+(mat<3, 4, T, P> const & m);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat3x4<T, P> operator-(tmat3x4<T, P> const & m);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<3, 4, T, P> operator-(mat<3, 4, T, P> const & m);
 
 	// -- Binary operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat3x4<T, P> operator+(tmat3x4<T, P> const & m, T scalar);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<3, 4, T, P> operator+(mat<3, 4, T, P> const & m, T scalar);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat3x4<T, P> operator+(tmat3x4<T, P> const & m1, tmat3x4<T, P> const & m2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<3, 4, T, P> operator+(mat<3, 4, T, P> const & m1, mat<3, 4, T, P> const & m2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat3x4<T, P> operator-(tmat3x4<T, P> const & m, T scalar);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<3, 4, T, P> operator-(mat<3, 4, T, P> const & m, T scalar);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat3x4<T, P> operator-(tmat3x4<T, P> const & m1, tmat3x4<T, P> const & m2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<3, 4, T, P> operator-(mat<3, 4, T, P> const & m1, mat<3, 4, T, P> const & m2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat3x4<T, P> operator*(tmat3x4<T, P> const & m, T scalar);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<3, 4, T, P> operator*(mat<3, 4, T, P> const & m, T scalar);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat3x4<T, P> operator*(T scalar, tmat3x4<T, P> const & m);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<3, 4, T, P> operator*(T scalar, mat<3, 4, T, P> const & m);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL typename tmat3x4<T, P>::col_type operator*(tmat3x4<T, P> const & m, typename tmat3x4<T, P>::row_type const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL typename mat<3, 4, T, P>::col_type operator*(mat<3, 4, T, P> const & m, typename mat<3, 4, T, P>::row_type const & v);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL typename tmat3x4<T, P>::row_type operator*(typename tmat3x4<T, P>::col_type const & v, tmat3x4<T, P> const & m);
+	template<typename T, precision P>
+	GLM_FUNC_DECL typename mat<3, 4, T, P>::row_type operator*(typename mat<3, 4, T, P>::col_type const & v, mat<3, 4, T, P> const & m);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat4x4<T, P> operator*(tmat3x4<T, P> const & m1,	tmat4x3<T, P> const & m2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<4, 4, T, P> operator*(mat<3, 4, T, P> const & m1,	mat<4, 3, T, P> const& m2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x4<T, P> operator*(tmat3x4<T, P> const & m1, tmat2x3<T, P> const & m2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<2, 4, T, P> operator*(mat<3, 4, T, P> const & m1, mat<2, 3, T, P> const & m2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat3x4<T, P> operator*(tmat3x4<T, P> const & m1,	tmat3x3<T, P> const & m2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<3, 4, T, P> operator*(mat<3, 4, T, P> const & m1,	mat<3, 3, T, P> const& m2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat3x4<T, P> operator/(tmat3x4<T, P> const & m, T scalar);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<3, 4, T, P> operator/(mat<3, 4, T, P> const & m, T scalar);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat3x4<T, P> operator/(T scalar, tmat3x4<T, P> const & m);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<3, 4, T, P> operator/(T scalar, mat<3, 4, T, P> const & m);
 
 	// -- Boolean operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL bool operator==(tmat3x4<T, P> const & m1, tmat3x4<T, P> const & m2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL bool operator==(mat<3, 4, T, P> const & m1, mat<3, 4, T, P> const & m2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL bool operator!=(tmat3x4<T, P> const & m1, tmat3x4<T, P> const & m2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL bool operator!=(mat<3, 4, T, P> const & m1, mat<3, 4, T, P> const & m2);
 }//namespace glm
 
 #ifndef GLM_EXTERNAL_TEMPLATE
diff --git a/glm/detail/type_mat3x4.inl b/glm/detail/type_mat3x4.inl
index 3596f267..73f4aebb 100644
--- a/glm/detail/type_mat3x4.inl
+++ b/glm/detail/type_mat3x4.inl
@@ -6,8 +6,8 @@ namespace glm
 	// -- Constructors --
 
 #	if !GLM_HAS_DEFAULTED_FUNCTIONS || !defined(GLM_FORCE_NO_CTOR_INIT)
-		template <typename T, precision P>
-		GLM_FUNC_QUALIFIER tmat3x4<T, P>::tmat3x4()
+		template<typename T, precision P>
+		GLM_FUNC_QUALIFIER mat<3, 4, T, P>::mat()
 		{
 #			ifndef GLM_FORCE_NO_CTOR_INIT 
 				this->value[0] = col_type(1, 0, 0, 0);
@@ -18,8 +18,8 @@ namespace glm
 #	endif
 
 #	if !GLM_HAS_DEFAULTED_FUNCTIONS
-		template <typename T, precision P>
-		GLM_FUNC_QUALIFIER tmat3x4<T, P>::tmat3x4(tmat3x4<T, P> const & m)
+		template<typename T, precision P>
+		GLM_FUNC_QUALIFIER mat<3, 4, T, P>::mat(mat<3, 4, T, P> const & m)
 		{
 			this->value[0] = m.value[0];
 			this->value[1] = m.value[1];
@@ -27,29 +27,29 @@ namespace glm
 		}
 #	endif//!GLM_HAS_DEFAULTED_FUNCTIONS
 
-	template <typename T, precision P>
-	template <precision Q>
-	GLM_FUNC_QUALIFIER tmat3x4<T, P>::tmat3x4(tmat3x4<T, Q> const & m)
+	template<typename T, precision P>
+	template<precision Q>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, P>::mat(mat<3, 4, T, Q> const & m)
 	{
 		this->value[0] = m.value[0];
 		this->value[1] = m.value[1];
 		this->value[2] = m.value[2];
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR tmat3x4<T, P>::tmat3x4(ctor)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR mat<3, 4, T, P>::mat(ctor)
 	{}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x4<T, P>::tmat3x4(T scalar)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, P>::mat(T scalar)
 	{
 		this->value[0] = col_type(scalar, 0, 0, 0);
 		this->value[1] = col_type(0, scalar, 0, 0);
 		this->value[2] = col_type(0, 0, scalar, 0);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x4<T, P>::tmat3x4
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, P>::mat 
 	(
 		T x0, T y0, T z0, T w0,
 		T x1, T y1, T z1, T w1,
@@ -61,8 +61,8 @@ namespace glm
 		this->value[2] = col_type(x2, y2, z2, w2);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x4<T, P>::tmat3x4
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, P>::mat 
 	(
 		col_type const & v0,
 		col_type const & v1,
@@ -76,12 +76,12 @@ namespace glm
 
 	// -- Conversion constructors --
 
-	template <typename T, precision P>
-	template <
+	template<typename T, precision P>
+	template<
 		typename X1, typename Y1, typename Z1, typename W1,
 		typename X2, typename Y2, typename Z2, typename W2,
 		typename X3, typename Y3, typename Z3, typename W3>
-	GLM_FUNC_QUALIFIER tmat3x4<T, P>::tmat3x4
+	GLM_FUNC_QUALIFIER mat<3, 4, T, P>::mat 
 	(
 		X1 x1, Y1 y1, Z1 z1, W1 w1,
 		X2 x2, Y2 y2, Z2 z2, W2 w2,
@@ -93,13 +93,13 @@ namespace glm
 		this->value[2] = col_type(static_cast<T>(x3), value_type(y3), value_type(z3), value_type(w3));
 	}
 	
-	template <typename T, precision P>
-	template <typename V1, typename V2, typename V3>
-	GLM_FUNC_QUALIFIER tmat3x4<T, P>::tmat3x4
+	template<typename T, precision P>
+	template<typename V1, typename V2, typename V3>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, P>::mat 
 	(
-		tvec4<V1, P> const & v1,
-		tvec4<V2, P> const & v2,
-		tvec4<V3, P> const & v3
+		vec<4, V1, P> const & v1,
+		vec<4, V2, P> const & v2,
+		vec<4, V3, P> const & v3
 	)
 	{
 		this->value[0] = col_type(v1);
@@ -109,73 +109,73 @@ namespace glm
 	
 	// -- Matrix conversions --
 
-	template <typename T, precision P>
-	template <typename U, precision Q>
-	GLM_FUNC_QUALIFIER tmat3x4<T, P>::tmat3x4(tmat3x4<U, Q> const & m)
+	template<typename T, precision P>
+	template<typename U, precision Q>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, P>::mat(mat<3, 4, U, Q> const & m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
 		this->value[2] = col_type(m[2]);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x4<T, P>::tmat3x4(tmat2x2<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, P>::mat(mat<2, 2, T, P> const & m)
 	{
 		this->value[0] = col_type(m[0], 0, 0);
 		this->value[1] = col_type(m[1], 0, 0);
 		this->value[2] = col_type(0, 0, 1, 0);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x4<T, P>::tmat3x4(tmat3x3<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, P>::mat(mat<3, 3, T, P> const & m)
 	{
 		this->value[0] = col_type(m[0], 0);
 		this->value[1] = col_type(m[1], 0);
 		this->value[2] = col_type(m[2], 0);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x4<T, P>::tmat3x4(tmat4x4<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, P>::mat(mat<4, 4, T, P> const & m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
 		this->value[2] = col_type(m[2]);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x4<T, P>::tmat3x4(tmat2x3<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, P>::mat(mat<2, 3, T, P> const & m)
 	{
 		this->value[0] = col_type(m[0], 0);
 		this->value[1] = col_type(m[1], 0);
 		this->value[2] = col_type(0, 0, 1, 0);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x4<T, P>::tmat3x4(tmat3x2<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, P>::mat(mat<3, 2, T, P> const & m)
 	{
 		this->value[0] = col_type(m[0], 0, 0);
 		this->value[1] = col_type(m[1], 0, 0);
 		this->value[2] = col_type(m[2], 1, 0);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x4<T, P>::tmat3x4(tmat2x4<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, P>::mat(mat<2, 4, T, P> const & m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
 		this->value[2] = col_type(0, 0, 1, 0);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x4<T, P>::tmat3x4(tmat4x2<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, P>::mat(mat<4, 2, T, P> const & m)
 	{
 		this->value[0] = col_type(m[0], 0, 0);
 		this->value[1] = col_type(m[1], 0, 0);
 		this->value[2] = col_type(m[2], 1, 0);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x4<T, P>::tmat3x4(tmat4x3<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, P>::mat(mat<4, 3, T, P> const & m)
 	{
 		this->value[0] = col_type(m[0], 0);
 		this->value[1] = col_type(m[1], 0);
@@ -184,15 +184,15 @@ namespace glm
 
 	// -- Accesses --
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER typename tmat3x4<T, P>::col_type & tmat3x4<T, P>::operator[](typename tmat3x4<T, P>::length_type i)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER typename mat<3, 4, T, P>::col_type & mat<3, 4, T, P>::operator[](typename mat<3, 4, T, P>::length_type i)
 	{
 		assert(i < this->length());
 		return this->value[i];
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER typename tmat3x4<T, P>::col_type const & tmat3x4<T, P>::operator[](typename tmat3x4<T, P>::length_type i) const
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER typename mat<3, 4, T, P>::col_type const & mat<3, 4, T, P>::operator[](typename mat<3, 4, T, P>::length_type i) const
 	{
 		assert(i < this->length());
 		return this->value[i];
@@ -201,8 +201,8 @@ namespace glm
 	// -- Unary updatable operators --
 
 #	if !GLM_HAS_DEFAULTED_FUNCTIONS
-		template <typename T, precision P>
-		GLM_FUNC_QUALIFIER tmat3x4<T, P>& tmat3x4<T, P>::operator=(tmat3x4<T, P> const & m)
+		template<typename T, precision P>
+		GLM_FUNC_QUALIFIER mat<3, 4, T, P>& mat<3, 4, T, P>::operator=(mat<3, 4, T, P> const & m)
 		{
 			this->value[0] = m[0];
 			this->value[1] = m[1];
@@ -211,9 +211,9 @@ namespace glm
 		}
 #	endif//!GLM_HAS_DEFAULTED_FUNCTIONS
 
-	template <typename T, precision P> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat3x4<T, P>& tmat3x4<T, P>::operator=(tmat3x4<U, P> const & m)
+	template<typename T, precision P> 
+	template<typename U> 
+	GLM_FUNC_QUALIFIER mat<3, 4, T, P>& mat<3, 4, T, P>::operator=(mat<3, 4, U, P> const & m)
 	{
 		this->value[0] = m[0];
 		this->value[1] = m[1];
@@ -221,9 +221,9 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat3x4<T, P>& tmat3x4<T, P>::operator+=(U s)
+	template<typename T, precision P> 
+	template<typename U> 
+	GLM_FUNC_QUALIFIER mat<3, 4, T, P>& mat<3, 4, T, P>::operator+=(U s)
 	{
 		this->value[0] += s;
 		this->value[1] += s;
@@ -231,9 +231,9 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat3x4<T, P>& tmat3x4<T, P>::operator+=(tmat3x4<U, P> const & m)
+	template<typename T, precision P> 
+	template<typename U> 
+	GLM_FUNC_QUALIFIER mat<3, 4, T, P>& mat<3, 4, T, P>::operator+=(mat<3, 4, U, P> const & m)
 	{
 		this->value[0] += m[0];
 		this->value[1] += m[1];
@@ -241,9 +241,9 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat3x4<T, P>& tmat3x4<T, P>::operator-=(U s)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, P>& mat<3, 4, T, P>::operator-=(U s)
 	{
 		this->value[0] -= s;
 		this->value[1] -= s;
@@ -251,9 +251,9 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat3x4<T, P>& tmat3x4<T, P>::operator-=(tmat3x4<U, P> const & m)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, P>& mat<3, 4, T, P>::operator-=(mat<3, 4, U, P> const & m)
 	{
 		this->value[0] -= m[0];
 		this->value[1] -= m[1];
@@ -261,9 +261,9 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat3x4<T, P>& tmat3x4<T, P>::operator*=(U s)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, P>& mat<3, 4, T, P>::operator*=(U s)
 	{
 		this->value[0] *= s;
 		this->value[1] *= s;
@@ -271,9 +271,9 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat3x4<T, P> & tmat3x4<T, P>::operator/=(U s)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, P> & mat<3, 4, T, P>::operator/=(U s)
 	{
 		this->value[0] /= s;
 		this->value[1] /= s;
@@ -283,8 +283,8 @@ namespace glm
 
 	// -- Increment and decrement operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x4<T, P>& tmat3x4<T, P>::operator++()
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, P>& mat<3, 4, T, P>::operator++()
 	{
 		++this->value[0];
 		++this->value[1];
@@ -292,8 +292,8 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x4<T, P>& tmat3x4<T, P>::operator--()
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, P>& mat<3, 4, T, P>::operator--()
 	{
 		--this->value[0];
 		--this->value[1];
@@ -301,34 +301,34 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x4<T, P> tmat3x4<T, P>::operator++(int)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, P> mat<3, 4, T, P>::operator++(int)
 	{
-		tmat3x4<T, P> Result(*this);
+		mat<3, 4, T, P> Result(*this);
 		++*this;
 		return Result;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x4<T, P> tmat3x4<T, P>::operator--(int)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, P> mat<3, 4, T, P>::operator--(int)
 	{
-		tmat3x4<T, P> Result(*this);
+		mat<3, 4, T, P> Result(*this);
 		--*this;
 		return Result;
 	}
 
 	// -- Unary arithmetic operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x4<T, P> operator+(tmat3x4<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, P> operator+(mat<3, 4, T, P> const & m)
 	{
 		return m;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x4<T, P> operator-(tmat3x4<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, P> operator-(mat<3, 4, T, P> const & m)
 	{
-		return tmat3x4<T, P>(
+		return mat<3, 4, T, P>(
 			-m[0],
 			-m[1],
 			-m[2]);
@@ -336,89 +336,89 @@ namespace glm
 
 	// -- Binary arithmetic operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x4<T, P> operator+(tmat3x4<T, P> const & m, T scalar)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, P> operator+(mat<3, 4, T, P> const & m, T scalar)
 	{
-		return tmat3x4<T, P>(
+		return mat<3, 4, T, P>(
 			m[0] + scalar,
 			m[1] + scalar,
 			m[2] + scalar);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x4<T, P> operator+(tmat3x4<T, P> const & m1, tmat3x4<T, P> const & m2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, P> operator+(mat<3, 4, T, P> const & m1, mat<3, 4, T, P> const & m2)
 	{
-		return tmat3x4<T, P>(
+		return mat<3, 4, T, P>(
 			m1[0] + m2[0],
 			m1[1] + m2[1],
 			m1[2] + m2[2]);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x4<T, P> operator-(tmat3x4<T, P> const & m,	T scalar)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, P> operator-(mat<3, 4, T, P> const & m,	T scalar)
 	{
-		return tmat3x4<T, P>(
+		return mat<3, 4, T, P>(
 			m[0] - scalar,
 			m[1] - scalar,
 			m[2] - scalar);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x4<T, P> operator-(tmat3x4<T, P> const & m1, tmat3x4<T, P> const & m2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, P> operator-(mat<3, 4, T, P> const & m1, mat<3, 4, T, P> const & m2)
 	{
-		return tmat3x4<T, P>(
+		return mat<3, 4, T, P>(
 			m1[0] - m2[0],
 			m1[1] - m2[1],
 			m1[2] - m2[2]);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x4<T, P> operator*(tmat3x4<T, P> const & m, T scalar)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, P> operator*(mat<3, 4, T, P> const & m, T scalar)
 	{
-		return tmat3x4<T, P>(
+		return mat<3, 4, T, P>(
 			m[0] * scalar,
 			m[1] * scalar,
 			m[2] * scalar);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x4<T, P> operator*(T scalar, tmat3x4<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, P> operator*(T scalar, mat<3, 4, T, P> const & m)
 	{
-		return tmat3x4<T, P>(
+		return mat<3, 4, T, P>(
 			m[0] * scalar,
 			m[1] * scalar,
 			m[2] * scalar);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER typename tmat3x4<T, P>::col_type operator*
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER typename mat<3, 4, T, P>::col_type operator*
 	(
-		tmat3x4<T, P> const & m,
-		typename tmat3x4<T, P>::row_type const & v
+		mat<3, 4, T, P> const& m,
+		typename mat<3, 4, T, P>::row_type const & v
 	)
 	{
-		return typename tmat3x4<T, P>::col_type(
+		return typename mat<3, 4, T, P>::col_type(
 			m[0][0] * v.x + m[1][0] * v.y + m[2][0] * v.z,
 			m[0][1] * v.x + m[1][1] * v.y + m[2][1] * v.z,
 			m[0][2] * v.x + m[1][2] * v.y + m[2][2] * v.z,
 			m[0][3] * v.x + m[1][3] * v.y + m[2][3] * v.z);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER typename tmat3x4<T, P>::row_type operator*
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER typename mat<3, 4, T, P>::row_type operator*
 	(
-		typename tmat3x4<T, P>::col_type const & v,
-		tmat3x4<T, P> const & m
+		typename mat<3, 4, T, P>::col_type const & v,
+		mat<3, 4, T, P> const& m
 	)
 	{
-		return typename tmat3x4<T, P>::row_type(
+		return typename mat<3, 4, T, P>::row_type(
 			v.x * m[0][0] + v.y * m[0][1] + v.z * m[0][2] + v.w * m[0][3],
 			v.x * m[1][0] + v.y * m[1][1] + v.z * m[1][2] + v.w * m[1][3],
 			v.x * m[2][0] + v.y * m[2][1] + v.z * m[2][2] + v.w * m[2][3]);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> operator*(tmat3x4<T, P> const & m1, tmat4x3<T, P> const & m2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, P> operator*(mat<3, 4, T, P> const & m1, mat<4, 3, T, P> const & m2)
 	{
 		const T SrcA00 = m1[0][0];
 		const T SrcA01 = m1[0][1];
@@ -446,7 +446,7 @@ namespace glm
 		const T SrcB31 = m2[3][1];
 		const T SrcB32 = m2[3][2];
 
-		tmat4x4<T, P> Result(uninitialize);
+		mat<4, 4, T, P> Result(uninitialize);
 		Result[0][0] = SrcA00 * SrcB00 + SrcA10 * SrcB01 + SrcA20 * SrcB02;
 		Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01 + SrcA21 * SrcB02;
 		Result[0][2] = SrcA02 * SrcB00 + SrcA12 * SrcB01 + SrcA22 * SrcB02;
@@ -466,10 +466,10 @@ namespace glm
 		return Result;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P> operator*(tmat3x4<T, P> const & m1, tmat2x3<T, P> const & m2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, P> operator*(mat<3, 4, T, P> const & m1, mat<2, 3, T, P> const & m2)
 	{
-		return tmat2x4<T, P>(
+		return mat<2, 4, T, P>(
 			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2],
 			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2],
 			m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1] + m1[2][2] * m2[0][2],
@@ -480,10 +480,10 @@ namespace glm
 			m1[0][3] * m2[1][0] + m1[1][3] * m2[1][1] + m1[2][3] * m2[1][2]);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x4<T, P> operator*(tmat3x4<T, P> const & m1, tmat3x3<T, P> const & m2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, P> operator*(mat<3, 4, T, P> const & m1, mat<3, 3, T, P> const & m2)
 	{
-		return tmat3x4<T, P>(
+		return mat<3, 4, T, P>(
 			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2],
 			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2],
 			m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1] + m1[2][2] * m2[0][2],
@@ -498,19 +498,19 @@ namespace glm
 			m1[0][3] * m2[2][0] + m1[1][3] * m2[2][1] + m1[2][3] * m2[2][2]);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x4<T, P> operator/(tmat3x4<T, P> const & m,	T scalar)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, P> operator/(mat<3, 4, T, P> const & m,	T scalar)
 	{
-		return tmat3x4<T, P>(
+		return mat<3, 4, T, P>(
 			m[0] / scalar,
 			m[1] / scalar,
 			m[2] / scalar);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x4<T, P> operator/(T scalar, tmat3x4<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, P> operator/(T scalar, mat<3, 4, T, P> const & m)
 	{
-		return tmat3x4<T, P>(
+		return mat<3, 4, T, P>(
 			scalar / m[0],
 			scalar / m[1],
 			scalar / m[2]);
@@ -518,14 +518,14 @@ namespace glm
 
 	// -- Boolean operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER bool operator==(tmat3x4<T, P> const & m1, tmat3x4<T, P> const & m2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER bool operator==(mat<3, 4, T, P> const & m1, mat<3, 4, T, P> const & m2)
 	{
 		return (m1[0] == m2[0]) && (m1[1] == m2[1]) && (m1[2] == m2[2]);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER bool operator!=(tmat3x4<T, P> const & m1, tmat3x4<T, P> const & m2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER bool operator!=(mat<3, 4, T, P> const & m1, mat<3, 4, T, P> const & m2)
 	{
 		return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]);
 	}
diff --git a/glm/detail/type_mat4x2.hpp b/glm/detail/type_mat4x2.hpp
index a899d943..feff316e 100644
--- a/glm/detail/type_mat4x2.hpp
+++ b/glm/detail/type_mat4x2.hpp
@@ -12,13 +12,13 @@
 
 namespace glm
 {
-	template <typename T, precision P = defaultp>
-	struct tmat4x2
+	template<typename T, precision P>
+	struct mat<4, 2, T, P>
 	{
-		typedef tvec2<T, P> col_type;
-		typedef tvec4<T, P> row_type;
-		typedef tmat4x2<T, P> type;
-		typedef tmat2x4<T, P> transpose_type;
+		typedef vec<2, T, P> col_type;
+		typedef vec<4, T, P> row_type;
+		typedef mat<4, 2, T, P> type;
+		typedef mat<2, 4, T, P> transpose_type;
 		typedef T value_type;
 
 	private:
@@ -27,19 +27,19 @@ namespace glm
 	public:
 		// -- Constructors --
 
-		GLM_FUNC_DECL tmat4x2() GLM_DEFAULT_CTOR;
-		GLM_FUNC_DECL tmat4x2(tmat4x2<T, P> const & m) GLM_DEFAULT;
-		template <precision Q>
-		GLM_FUNC_DECL tmat4x2(tmat4x2<T, Q> const & m);
+		GLM_FUNC_DECL mat() GLM_DEFAULT_CTOR;
+		GLM_FUNC_DECL mat(mat<4, 2, T, P> const & m) GLM_DEFAULT;
+		template<precision Q>
+		GLM_FUNC_DECL mat(mat<4, 2, T, Q> const & m);
 
-		GLM_FUNC_DECL GLM_CONSTEXPR_CTOR explicit tmat4x2(ctor);
-		GLM_FUNC_DECL explicit tmat4x2(T scalar);
-		GLM_FUNC_DECL tmat4x2(
+		GLM_FUNC_DECL GLM_CONSTEXPR_CTOR explicit mat(ctor);
+		GLM_FUNC_DECL explicit mat(T scalar);
+		GLM_FUNC_DECL mat(
 			T x0, T y0,
 			T x1, T y1,
 			T x2, T y2,
 			T x3, T y3);
-		GLM_FUNC_DECL tmat4x2(
+		GLM_FUNC_DECL mat(
 			col_type const & v0,
 			col_type const & v1,
 			col_type const & v2,
@@ -47,37 +47,37 @@ namespace glm
 
 		// -- Conversions --
 
-		template <
+		template<
 			typename X1, typename Y1,
 			typename X2, typename Y2,
 			typename X3, typename Y3,
 			typename X4, typename Y4>
-		GLM_FUNC_DECL tmat4x2(
+		GLM_FUNC_DECL mat(
 			X1 x1, Y1 y1,
 			X2 x2, Y2 y2,
 			X3 x3, Y3 y3,
 			X4 x4, Y4 y4);
 
-		template <typename V1, typename V2, typename V3, typename V4>
-		GLM_FUNC_DECL tmat4x2(
-			tvec2<V1, P> const & v1,
-			tvec2<V2, P> const & v2,
-			tvec2<V3, P> const & v3,
-			tvec2<V4, P> const & v4);
+		template<typename V1, typename V2, typename V3, typename V4>
+		GLM_FUNC_DECL mat(
+			vec<2, V1, P> const & v1,
+			vec<2, V2, P> const & v2,
+			vec<2, V3, P> const & v3,
+			vec<2, V4, P> const & v4);
 
 		// -- Matrix conversions --
 
-		template <typename U, precision Q>
-		GLM_FUNC_DECL GLM_EXPLICIT tmat4x2(tmat4x2<U, Q> const & m);
+		template<typename U, precision Q>
+		GLM_FUNC_DECL GLM_EXPLICIT mat(mat<4, 2, U, Q> const & m);
 
-		GLM_FUNC_DECL GLM_EXPLICIT tmat4x2(tmat2x2<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat4x2(tmat3x3<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat4x2(tmat4x4<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat4x2(tmat2x3<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat4x2(tmat3x2<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat4x2(tmat2x4<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat4x2(tmat4x3<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat4x2(tmat3x4<T, P> const & x);
+		GLM_FUNC_DECL GLM_EXPLICIT mat(mat<2, 2, T, P> const & x);
+		GLM_FUNC_DECL GLM_EXPLICIT mat(mat<3, 3, T, P> const & x);
+		GLM_FUNC_DECL GLM_EXPLICIT mat(mat<4, 4, T, P> const & x);
+		GLM_FUNC_DECL GLM_EXPLICIT mat(mat<2, 3, T, P> const & x);
+		GLM_FUNC_DECL GLM_EXPLICIT mat(mat<3, 2, T, P> const & x);
+		GLM_FUNC_DECL GLM_EXPLICIT mat(mat<2, 4, T, P> const & x);
+		GLM_FUNC_DECL GLM_EXPLICIT mat(mat<4, 3, T, P> const & x);
+		GLM_FUNC_DECL GLM_EXPLICIT mat(mat<3, 4, T, P> const & x);
 
 		// -- Accesses --
 
@@ -89,87 +89,87 @@ namespace glm
 
 		// -- Unary arithmetic operators --
 
-		GLM_FUNC_DECL tmat4x2<T, P> & operator=(tmat4x2<T, P> const & m) GLM_DEFAULT;
+		GLM_FUNC_DECL mat<4, 2, T, P> & operator=(mat<4, 2, T, P> const & m) GLM_DEFAULT;
 
-		template <typename U>
-		GLM_FUNC_DECL tmat4x2<T, P> & operator=(tmat4x2<U, P> const & m);
-		template <typename U>
-		GLM_FUNC_DECL tmat4x2<T, P> & operator+=(U s);
-		template <typename U>
-		GLM_FUNC_DECL tmat4x2<T, P> & operator+=(tmat4x2<U, P> const & m);
-		template <typename U>
-		GLM_FUNC_DECL tmat4x2<T, P> & operator-=(U s);
-		template <typename U>
-		GLM_FUNC_DECL tmat4x2<T, P> & operator-=(tmat4x2<U, P> const & m);
-		template <typename U>
-		GLM_FUNC_DECL tmat4x2<T, P> & operator*=(U s);
-		template <typename U>
-		GLM_FUNC_DECL tmat4x2<T, P> & operator/=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<4, 2, T, P> & operator=(mat<4, 2, U, P> const & m);
+		template<typename U>
+		GLM_FUNC_DECL mat<4, 2, T, P> & operator+=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<4, 2, T, P> & operator+=(mat<4, 2, U, P> const & m);
+		template<typename U>
+		GLM_FUNC_DECL mat<4, 2, T, P> & operator-=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<4, 2, T, P> & operator-=(mat<4, 2, U, P> const & m);
+		template<typename U>
+		GLM_FUNC_DECL mat<4, 2, T, P> & operator*=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<4, 2, T, P> & operator/=(U s);
 
 		// -- Increment and decrement operators --
 
-		GLM_FUNC_DECL tmat4x2<T, P> & operator++ ();
-		GLM_FUNC_DECL tmat4x2<T, P> & operator-- ();
-		GLM_FUNC_DECL tmat4x2<T, P> operator++(int);
-		GLM_FUNC_DECL tmat4x2<T, P> operator--(int);
+		GLM_FUNC_DECL mat<4, 2, T, P> & operator++ ();
+		GLM_FUNC_DECL mat<4, 2, T, P> & operator-- ();
+		GLM_FUNC_DECL mat<4, 2, T, P> operator++(int);
+		GLM_FUNC_DECL mat<4, 2, T, P> operator--(int);
 	};
 
 	// -- Unary operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat4x2<T, P> operator+(tmat4x2<T, P> const & m);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<4, 2, T, P> operator+(mat<4, 2, T, P> const & m);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat4x2<T, P> operator-(tmat4x2<T, P> const & m);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<4, 2, T, P> operator-(mat<4, 2, T, P> const & m);
 
 	// -- Binary operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat4x2<T, P> operator+(tmat4x2<T, P> const & m, T scalar);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<4, 2, T, P> operator+(mat<4, 2, T, P> const & m, T scalar);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat4x2<T, P> operator+(tmat4x2<T, P> const & m1, tmat4x2<T, P> const & m2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<4, 2, T, P> operator+(mat<4, 2, T, P> const & m1, mat<4, 2, T, P> const & m2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat4x2<T, P> operator-(tmat4x2<T, P> const & m, T scalar);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<4, 2, T, P> operator-(mat<4, 2, T, P> const & m, T scalar);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat4x2<T, P> operator-(tmat4x2<T, P> const & m1,	tmat4x2<T, P> const & m2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<4, 2, T, P> operator-(mat<4, 2, T, P> const & m1,	mat<4, 2, T, P> const& m2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat4x2<T, P> operator*(tmat4x2<T, P> const & m, T scalar);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<4, 2, T, P> operator*(mat<4, 2, T, P> const & m, T scalar);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat4x2<T, P> operator*(T scalar, tmat4x2<T, P> const & m);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<4, 2, T, P> operator*(T scalar, mat<4, 2, T, P> const & m);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL typename tmat4x2<T, P>::col_type operator*(tmat4x2<T, P> const & m, typename tmat4x2<T, P>::row_type const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL typename mat<4, 2, T, P>::col_type operator*(mat<4, 2, T, P> const & m, typename mat<4, 2, T, P>::row_type const & v);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL typename tmat4x2<T, P>::row_type operator*(typename tmat4x2<T, P>::col_type const & v, tmat4x2<T, P> const & m);
+	template<typename T, precision P>
+	GLM_FUNC_DECL typename mat<4, 2, T, P>::row_type operator*(typename mat<4, 2, T, P>::col_type const & v, mat<4, 2, T, P> const & m);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x2<T, P> operator*(tmat4x2<T, P> const & m1, tmat2x4<T, P> const & m2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<2, 2, T, P> operator*(mat<4, 2, T, P> const & m1, mat<2, 4, T, P> const & m2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat3x2<T, P> operator*(tmat4x2<T, P> const & m1, tmat3x4<T, P> const & m2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<3, 2, T, P> operator*(mat<4, 2, T, P> const & m1, mat<3, 4, T, P> const & m2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat4x2<T, P> operator*(tmat4x2<T, P> const & m1, tmat4x4<T, P> const & m2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<4, 2, T, P> operator*(mat<4, 2, T, P> const & m1, mat<4, 4, T, P> const & m2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat4x2<T, P> operator/(tmat4x2<T, P> const & m, T scalar);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<4, 2, T, P> operator/(mat<4, 2, T, P> const & m, T scalar);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat4x2<T, P> operator/(T scalar, tmat4x2<T, P> const & m);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<4, 2, T, P> operator/(T scalar, mat<4, 2, T, P> const & m);
 
 	// -- Boolean operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL bool operator==(tmat4x2<T, P> const & m1, tmat4x2<T, P> const & m2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL bool operator==(mat<4, 2, T, P> const & m1, mat<4, 2, T, P> const & m2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL bool operator!=(tmat4x2<T, P> const & m1, tmat4x2<T, P> const & m2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL bool operator!=(mat<4, 2, T, P> const & m1, mat<4, 2, T, P> const & m2);
 }//namespace glm
 
 #ifndef GLM_EXTERNAL_TEMPLATE
diff --git a/glm/detail/type_mat4x2.inl b/glm/detail/type_mat4x2.inl
index 76e8ffaa..68d34630 100644
--- a/glm/detail/type_mat4x2.inl
+++ b/glm/detail/type_mat4x2.inl
@@ -6,8 +6,8 @@ namespace glm
 	// -- Constructors --
 
 #	if !GLM_HAS_DEFAULTED_FUNCTIONS || !defined(GLM_FORCE_NO_CTOR_INIT)
-		template <typename T, precision P> 
-		GLM_FUNC_QUALIFIER tmat4x2<T, P>::tmat4x2()
+		template<typename T, precision P> 
+		GLM_FUNC_QUALIFIER mat<4, 2, T, P>::mat()
 		{
 #			ifndef GLM_FORCE_NO_CTOR_INIT 
 				this->value[0] = col_type(1, 0);
@@ -19,8 +19,8 @@ namespace glm
 #	endif
 
 #	if !GLM_HAS_DEFAULTED_FUNCTIONS
-		template <typename T, precision P>
-		GLM_FUNC_QUALIFIER tmat4x2<T, P>::tmat4x2(tmat4x2<T, P> const & m)
+		template<typename T, precision P>
+		GLM_FUNC_QUALIFIER mat<4, 2, T, P>::mat(mat<4, 2, T, P> const & m)
 		{
 			this->value[0] = m.value[0];
 			this->value[1] = m.value[1];
@@ -29,9 +29,9 @@ namespace glm
 		}
 #	endif//!GLM_HAS_DEFAULTED_FUNCTIONS
 
-	template <typename T, precision P>
-	template <precision Q>
-	GLM_FUNC_QUALIFIER tmat4x2<T, P>::tmat4x2(tmat4x2<T, Q> const & m)
+	template<typename T, precision P>
+	template<precision Q>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, P>::mat(mat<4, 2, T, Q> const & m)
 	{
 		this->value[0] = m.value[0];
 		this->value[1] = m.value[1];
@@ -39,12 +39,12 @@ namespace glm
 		this->value[3] = m.value[3];
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR tmat4x2<T, P>::tmat4x2(ctor)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR mat<4, 2, T, P>::mat(ctor)
 	{}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x2<T, P>::tmat4x2(T scalar)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, P>::mat(T scalar)
 	{
 		this->value[0] = col_type(scalar, 0);
 		this->value[1] = col_type(0, scalar);
@@ -52,8 +52,8 @@ namespace glm
 		this->value[3] = col_type(0, 0);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x2<T, P>::tmat4x2
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, P>::mat
 	(
 		T x0, T y0,
 		T x1, T y1,
@@ -67,8 +67,8 @@ namespace glm
 		this->value[3] = col_type(x3, y3);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x2<T, P>::tmat4x2
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, P>::mat
 	(
 		col_type const & v0,
 		col_type const & v1,
@@ -84,13 +84,13 @@ namespace glm
 
 	// -- Conversion constructors --
 
-	template <typename T, precision P>
-	template <
+	template<typename T, precision P>
+	template<
 		typename X1, typename Y1,
 		typename X2, typename Y2,
 		typename X3, typename Y3,
 		typename X4, typename Y4>
-	GLM_FUNC_QUALIFIER tmat4x2<T, P>::tmat4x2
+	GLM_FUNC_QUALIFIER mat<4, 2, T, P>::mat
 	(
 		X1 x1, Y1 y1,
 		X2 x2, Y2 y2,
@@ -104,14 +104,14 @@ namespace glm
 		this->value[3] = col_type(static_cast<T>(x4), value_type(y4));
 	}
 	
-	template <typename T, precision P>
-	template <typename V1, typename V2, typename V3, typename V4>
-	GLM_FUNC_QUALIFIER tmat4x2<T, P>::tmat4x2
+	template<typename T, precision P>
+	template<typename V1, typename V2, typename V3, typename V4>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, P>::mat
 	(
-		tvec2<V1, P> const & v1,
-		tvec2<V2, P> const & v2,
-		tvec2<V3, P> const & v3,
-		tvec2<V4, P> const & v4
+		vec<2, V1, P> const & v1,
+		vec<2, V2, P> const & v2,
+		vec<2, V3, P> const & v3,
+		vec<2, V4, P> const & v4
 	)
 	{
 		this->value[0] = col_type(v1);
@@ -122,9 +122,9 @@ namespace glm
 
 	// -- Conversion --
 
-	template <typename T, precision P>
-	template <typename U, precision Q>
-	GLM_FUNC_QUALIFIER tmat4x2<T, P>::tmat4x2(tmat4x2<U, Q> const & m)
+	template<typename T, precision P>
+	template<typename U, precision Q>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, P>::mat(mat<4, 2, U, Q> const & m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
@@ -132,8 +132,8 @@ namespace glm
 		this->value[3] = col_type(m[3]);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x2<T, P>::tmat4x2(tmat2x2<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, P>::mat(mat<2, 2, T, P> const & m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
@@ -141,8 +141,8 @@ namespace glm
 		this->value[3] = col_type(0);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x2<T, P>::tmat4x2(tmat3x3<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, P>::mat(mat<3, 3, T, P> const & m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
@@ -150,8 +150,8 @@ namespace glm
 		this->value[3] = col_type(0);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x2<T, P>::tmat4x2(tmat4x4<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, P>::mat(mat<4, 4, T, P> const & m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
@@ -159,8 +159,8 @@ namespace glm
 		this->value[3] = col_type(m[3]);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x2<T, P>::tmat4x2(tmat2x3<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, P>::mat(mat<2, 3, T, P> const & m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
@@ -168,8 +168,8 @@ namespace glm
 		this->value[3] = col_type(0);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x2<T, P>::tmat4x2(tmat3x2<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, P>::mat(mat<3, 2, T, P> const & m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
@@ -177,8 +177,8 @@ namespace glm
 		this->value[3] = col_type(0);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x2<T, P>::tmat4x2(tmat2x4<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, P>::mat(mat<2, 4, T, P> const & m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
@@ -186,8 +186,8 @@ namespace glm
 		this->value[3] = col_type(0);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x2<T, P>::tmat4x2(tmat4x3<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, P>::mat(mat<4, 3, T, P> const & m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
@@ -195,8 +195,8 @@ namespace glm
 		this->value[3] = col_type(m[3]);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x2<T, P>::tmat4x2(tmat3x4<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, P>::mat(mat<3, 4, T, P> const & m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
@@ -206,15 +206,15 @@ namespace glm
 
 	// -- Accesses --
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER typename tmat4x2<T, P>::col_type & tmat4x2<T, P>::operator[](typename tmat4x2<T, P>::length_type i)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER typename mat<4, 2, T, P>::col_type & mat<4, 2, T, P>::operator[](typename mat<4, 2, T, P>::length_type i)
 	{
 		assert(i < this->length());
 		return this->value[i];
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER typename tmat4x2<T, P>::col_type const & tmat4x2<T, P>::operator[](typename tmat4x2<T, P>::length_type i) const
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER typename mat<4, 2, T, P>::col_type const & mat<4, 2, T, P>::operator[](typename mat<4, 2, T, P>::length_type i) const
 	{
 		assert(i < this->length());
 		return this->value[i];
@@ -223,8 +223,8 @@ namespace glm
 	// -- Unary updatable operators --
 
 #	if !GLM_HAS_DEFAULTED_FUNCTIONS
-		template <typename T, precision P>
-		GLM_FUNC_QUALIFIER tmat4x2<T, P>& tmat4x2<T, P>::operator=(tmat4x2<T, P> const & m)
+		template<typename T, precision P>
+		GLM_FUNC_QUALIFIER mat<4, 2, T, P>& mat<4, 2, T, P>::operator=(mat<4, 2, T, P> const & m)
 		{
 			this->value[0] = m[0];
 			this->value[1] = m[1];
@@ -234,9 +234,9 @@ namespace glm
 		}
 #	endif//!GLM_HAS_DEFAULTED_FUNCTIONS
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat4x2<T, P>& tmat4x2<T, P>::operator=(tmat4x2<U, P> const & m)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, P>& mat<4, 2, T, P>::operator=(mat<4, 2, U, P> const & m)
 	{
 		this->value[0] = m[0];
 		this->value[1] = m[1];
@@ -245,9 +245,9 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat4x2<T, P> & tmat4x2<T, P>::operator+=(U s)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, P> & mat<4, 2, T, P>::operator+=(U s)
 	{
 		this->value[0] += s;
 		this->value[1] += s;
@@ -256,9 +256,9 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat4x2<T, P> & tmat4x2<T, P>::operator+=(tmat4x2<U, P> const & m)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, P> & mat<4, 2, T, P>::operator+=(mat<4, 2, U, P> const & m)
 	{
 		this->value[0] += m[0];
 		this->value[1] += m[1];
@@ -267,9 +267,9 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat4x2<T, P> & tmat4x2<T, P>::operator-=(U s)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, P> & mat<4, 2, T, P>::operator-=(U s)
 	{
 		this->value[0] -= s;
 		this->value[1] -= s;
@@ -278,9 +278,9 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat4x2<T, P> & tmat4x2<T, P>::operator-=(tmat4x2<U, P> const & m)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, P> & mat<4, 2, T, P>::operator-=(mat<4, 2, U, P> const & m)
 	{
 		this->value[0] -= m[0];
 		this->value[1] -= m[1];
@@ -289,9 +289,9 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat4x2<T, P> & tmat4x2<T, P>::operator*=(U s)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, P> & mat<4, 2, T, P>::operator*=(U s)
 	{
 		this->value[0] *= s;
 		this->value[1] *= s;
@@ -300,9 +300,9 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat4x2<T, P> & tmat4x2<T, P>::operator/=(U s)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, P> & mat<4, 2, T, P>::operator/=(U s)
 	{
 		this->value[0] /= s;
 		this->value[1] /= s;
@@ -313,8 +313,8 @@ namespace glm
 
 	// -- Increment and decrement operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x2<T, P> & tmat4x2<T, P>::operator++()
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, P> & mat<4, 2, T, P>::operator++()
 	{
 		++this->value[0];
 		++this->value[1];
@@ -323,8 +323,8 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x2<T, P> & tmat4x2<T, P>::operator--()
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, P> & mat<4, 2, T, P>::operator--()
 	{
 		--this->value[0];
 		--this->value[1];
@@ -333,34 +333,34 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x2<T, P> tmat4x2<T, P>::operator++(int)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, P> mat<4, 2, T, P>::operator++(int)
 	{
-		tmat4x2<T, P> Result(*this);
+		mat<4, 2, T, P> Result(*this);
 		++*this;
 		return Result;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x2<T, P> tmat4x2<T, P>::operator--(int)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, P> mat<4, 2, T, P>::operator--(int)
 	{
-		tmat4x2<T, P> Result(*this);
+		mat<4, 2, T, P> Result(*this);
 		--*this;
 		return Result;
 	}
 
 	// -- Unary arithmetic operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x2<T, P> operator+(tmat4x2<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, P> operator+(mat<4, 2, T, P> const & m)
 	{
 		return m;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x2<T, P> operator-(tmat4x2<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, P> operator-(mat<4, 2, T, P> const & m)
 	{
-		return tmat4x2<T, P>(
+		return mat<4, 2, T, P>(
 			-m[0],
 			-m[1],
 			-m[2],
@@ -369,86 +369,86 @@ namespace glm
 
 	// -- Binary arithmetic operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x2<T, P> operator+(tmat4x2<T, P> const & m, T scalar)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, P> operator+(mat<4, 2, T, P> const & m, T scalar)
 	{
-		return tmat4x2<T, P>(
+		return mat<4, 2, T, P>(
 			m[0] + scalar,
 			m[1] + scalar,
 			m[2] + scalar,
 			m[3] + scalar);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x2<T, P> operator+(tmat4x2<T, P> const & m1, tmat4x2<T, P> const & m2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, P> operator+(mat<4, 2, T, P> const & m1, mat<4, 2, T, P> const & m2)
 	{
-		return tmat4x2<T, P>(
+		return mat<4, 2, T, P>(
 			m1[0] + m2[0],
 			m1[1] + m2[1],
 			m1[2] + m2[2],
 			m1[3] + m2[3]);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x2<T, P> operator-(tmat4x2<T, P> const & m, T scalar)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, P> operator-(mat<4, 2, T, P> const & m, T scalar)
 	{
-		return tmat4x2<T, P>(
+		return mat<4, 2, T, P>(
 			m[0] - scalar,
 			m[1] - scalar,
 			m[2] - scalar,
 			m[3] - scalar);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x2<T, P> operator-(tmat4x2<T, P> const & m1, tmat4x2<T, P> const & m2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, P> operator-(mat<4, 2, T, P> const & m1, mat<4, 2, T, P> const & m2)
 	{
-		return tmat4x2<T, P>(
+		return mat<4, 2, T, P>(
 			m1[0] - m2[0],
 			m1[1] - m2[1],
 			m1[2] - m2[2],
 			m1[3] - m2[3]);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x2<T, P> operator*(tmat4x2<T, P> const & m, T scalar)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, P> operator*(mat<4, 2, T, P> const & m, T scalar)
 	{
-		return tmat4x2<T, P>(
+		return mat<4, 2, T, P>(
 			m[0] * scalar,
 			m[1] * scalar,
 			m[2] * scalar,
 			m[3] * scalar);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x2<T, P> operator*(T scalar, tmat4x2<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, P> operator*(T scalar, mat<4, 2, T, P> const & m)
 	{
-		return tmat4x2<T, P>(
+		return mat<4, 2, T, P>(
 			m[0] * scalar,
 			m[1] * scalar,
 			m[2] * scalar,
 			m[3] * scalar);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER typename tmat4x2<T, P>::col_type operator*(tmat4x2<T, P> const & m, typename tmat4x2<T, P>::row_type const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER typename mat<4, 2, T, P>::col_type operator*(mat<4, 2, T, P> const & m, typename mat<4, 2, T, P>::row_type const & v)
 	{
-		return typename tmat4x2<T, P>::col_type(
+		return typename mat<4, 2, T, P>::col_type(
 			m[0][0] * v.x + m[1][0] * v.y + m[2][0] * v.z + m[3][0] * v.w,
 			m[0][1] * v.x + m[1][1] * v.y + m[2][1] * v.z + m[3][1] * v.w);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER typename tmat4x2<T, P>::row_type operator*(typename tmat4x2<T, P>::col_type const & v, tmat4x2<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER typename mat<4, 2, T, P>::row_type operator*(typename mat<4, 2, T, P>::col_type const & v, mat<4, 2, T, P> const & m)
 	{
-		return typename tmat4x2<T, P>::row_type(
+		return typename mat<4, 2, T, P>::row_type(
 			v.x * m[0][0] + v.y * m[0][1],
 			v.x * m[1][0] + v.y * m[1][1],
 			v.x * m[2][0] + v.y * m[2][1],
 			v.x * m[3][0] + v.y * m[3][1]);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P> operator*(tmat4x2<T, P> const & m1, tmat2x4<T, P> const & m2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, P> operator*(mat<4, 2, T, P> const & m1, mat<2, 4, T, P> const & m2)
 	{
 		T const SrcA00 = m1[0][0];
 		T const SrcA01 = m1[0][1];
@@ -468,7 +468,7 @@ namespace glm
 		T const SrcB12 = m2[1][2];
 		T const SrcB13 = m2[1][3];
 
-		tmat2x2<T, P> Result(uninitialize);
+		mat<2, 2, T, P> Result(uninitialize);
 		Result[0][0] = SrcA00 * SrcB00 + SrcA10 * SrcB01 + SrcA20 * SrcB02 + SrcA30 * SrcB03;
 		Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01 + SrcA21 * SrcB02 + SrcA31 * SrcB03;
 		Result[1][0] = SrcA00 * SrcB10 + SrcA10 * SrcB11 + SrcA20 * SrcB12 + SrcA30 * SrcB13;
@@ -476,10 +476,10 @@ namespace glm
 		return Result;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x2<T, P> operator*(tmat4x2<T, P> const & m1, tmat3x4<T, P> const & m2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, P> operator*(mat<4, 2, T, P> const & m1, mat<3, 4, T, P> const & m2)
 	{
-		return tmat3x2<T, P>(
+		return mat<3, 2, T, P>(
 			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2] + m1[3][0] * m2[0][3],
 			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2] + m1[3][1] * m2[0][3],
 			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2] + m1[3][0] * m2[1][3],
@@ -488,10 +488,10 @@ namespace glm
 			m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1] + m1[2][1] * m2[2][2] + m1[3][1] * m2[2][3]);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x2<T, P> operator*(tmat4x2<T, P> const & m1, tmat4x4<T, P> const & m2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, P> operator*(mat<4, 2, T, P> const & m1, mat<4, 4, T, P> const & m2)
 	{
-		return tmat4x2<T, P>(
+		return mat<4, 2, T, P>(
 			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2] + m1[3][0] * m2[0][3],
 			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2] + m1[3][1] * m2[0][3],
 			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2] + m1[3][0] * m2[1][3],
@@ -502,20 +502,20 @@ namespace glm
 			m1[0][1] * m2[3][0] + m1[1][1] * m2[3][1] + m1[2][1] * m2[3][2] + m1[3][1] * m2[3][3]);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x2<T, P> operator/(tmat4x2<T, P> const & m, T scalar)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, P> operator/(mat<4, 2, T, P> const & m, T scalar)
 	{
-		return tmat4x2<T, P>(
+		return mat<4, 2, T, P>(
 			m[0] / scalar,
 			m[1] / scalar,
 			m[2] / scalar,
 			m[3] / scalar);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x2<T, P> operator/(T scalar, tmat4x2<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, P> operator/(T scalar, mat<4, 2, T, P> const & m)
 	{
-		return tmat4x2<T, P>(
+		return mat<4, 2, T, P>(
 			scalar / m[0],
 			scalar / m[1],
 			scalar / m[2],
@@ -524,14 +524,14 @@ namespace glm
 
 	// -- Boolean operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER bool operator==(tmat4x2<T, P> const & m1, tmat4x2<T, P> const & m2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER bool operator==(mat<4, 2, T, P> const & m1, mat<4, 2, T, P> const & m2)
 	{
 		return (m1[0] == m2[0]) && (m1[1] == m2[1]) && (m1[2] == m2[2]) && (m1[3] == m2[3]);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER bool operator!=(tmat4x2<T, P> const & m1, tmat4x2<T, P> const & m2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER bool operator!=(mat<4, 2, T, P> const & m1, mat<4, 2, T, P> const & m2)
 	{
 		return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]) || (m1[3] != m2[3]);
 	}
diff --git a/glm/detail/type_mat4x3.hpp b/glm/detail/type_mat4x3.hpp
index c696735f..2efa8699 100644
--- a/glm/detail/type_mat4x3.hpp
+++ b/glm/detail/type_mat4x3.hpp
@@ -12,13 +12,13 @@
 
 namespace glm
 {
-	template <typename T, precision P = defaultp>
-	struct tmat4x3
+	template<typename T, precision P>
+	struct mat<4, 3, T, P>
 	{
-		typedef tvec3<T, P> col_type;
-		typedef tvec4<T, P> row_type;
-		typedef tmat4x3<T, P> type;
-		typedef tmat3x4<T, P> transpose_type;
+		typedef vec<3, T, P> col_type;
+		typedef vec<4, T, P> row_type;
+		typedef mat<4, 3, T, P> type;
+		typedef mat<3, 4, T, P> transpose_type;
 		typedef T value_type;
 
 	private:
@@ -27,19 +27,19 @@ namespace glm
 	public:
 		// -- Constructors --
 
-		GLM_FUNC_DECL tmat4x3() GLM_DEFAULT_CTOR;
-		GLM_FUNC_DECL tmat4x3(tmat4x3<T, P> const & m) GLM_DEFAULT;
-		template <precision Q>
-		GLM_FUNC_DECL tmat4x3(tmat4x3<T, Q> const & m);
+		GLM_FUNC_DECL mat() GLM_DEFAULT_CTOR;
+		GLM_FUNC_DECL mat(mat<4, 3, T, P> const & m) GLM_DEFAULT;
+		template<precision Q>
+		GLM_FUNC_DECL mat(mat<4, 3, T, Q> const & m);
 
-		GLM_FUNC_DECL GLM_CONSTEXPR_CTOR explicit tmat4x3(ctor);
-		GLM_FUNC_DECL explicit tmat4x3(T const & x);
-		GLM_FUNC_DECL tmat4x3(
+		GLM_FUNC_DECL GLM_CONSTEXPR_CTOR explicit mat(ctor);
+		GLM_FUNC_DECL explicit mat(T const & x);
+		GLM_FUNC_DECL mat(
 			T const & x0, T const & y0, T const & z0,
 			T const & x1, T const & y1, T const & z1,
 			T const & x2, T const & y2, T const & z2,
 			T const & x3, T const & y3, T const & z3);
-		GLM_FUNC_DECL tmat4x3(
+		GLM_FUNC_DECL mat(
 			col_type const & v0,
 			col_type const & v1,
 			col_type const & v2,
@@ -47,37 +47,37 @@ namespace glm
 
 		// -- Conversions --
 
-		template <
+		template<
 			typename X1, typename Y1, typename Z1,
 			typename X2, typename Y2, typename Z2,
 			typename X3, typename Y3, typename Z3,
 			typename X4, typename Y4, typename Z4>
-		GLM_FUNC_DECL tmat4x3(
+		GLM_FUNC_DECL mat(
 			X1 const & x1, Y1 const & y1, Z1 const & z1,
 			X2 const & x2, Y2 const & y2, Z2 const & z2,
 			X3 const & x3, Y3 const & y3, Z3 const & z3,
 			X4 const & x4, Y4 const & y4, Z4 const & z4);
 
-		template <typename V1, typename V2, typename V3, typename V4>
-		GLM_FUNC_DECL tmat4x3(
-			tvec3<V1, P> const & v1,
-			tvec3<V2, P> const & v2,
-			tvec3<V3, P> const & v3,
-			tvec3<V4, P> const & v4);
+		template<typename V1, typename V2, typename V3, typename V4>
+		GLM_FUNC_DECL mat(
+			vec<3, V1, P> const & v1,
+			vec<3, V2, P> const & v2,
+			vec<3, V3, P> const & v3,
+			vec<3, V4, P> const & v4);
 
 		// -- Matrix conversions --
 
-		template <typename U, precision Q>
-		GLM_FUNC_DECL GLM_EXPLICIT tmat4x3(tmat4x3<U, Q> const & m);
+		template<typename U, precision Q>
+		GLM_FUNC_DECL GLM_EXPLICIT mat(mat<4, 3, U, Q> const & m);
 
-		GLM_FUNC_DECL GLM_EXPLICIT tmat4x3(tmat2x2<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat4x3(tmat3x3<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat4x3(tmat4x4<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat4x3(tmat2x3<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat4x3(tmat3x2<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat4x3(tmat2x4<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat4x3(tmat4x2<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat4x3(tmat3x4<T, P> const & x);
+		GLM_FUNC_DECL GLM_EXPLICIT mat(mat<2, 2, T, P> const & x);
+		GLM_FUNC_DECL GLM_EXPLICIT mat(mat<3, 3, T, P> const & x);
+		GLM_FUNC_DECL GLM_EXPLICIT mat(mat<4, 4, T, P> const & x);
+		GLM_FUNC_DECL GLM_EXPLICIT mat(mat<2, 3, T, P> const & x);
+		GLM_FUNC_DECL GLM_EXPLICIT mat(mat<3, 2, T, P> const & x);
+		GLM_FUNC_DECL GLM_EXPLICIT mat(mat<2, 4, T, P> const & x);
+		GLM_FUNC_DECL GLM_EXPLICIT mat(mat<4, 2, T, P> const & x);
+		GLM_FUNC_DECL GLM_EXPLICIT mat(mat<3, 4, T, P> const & x);
 
 		// -- Accesses --
 
@@ -89,87 +89,87 @@ namespace glm
 
 		// -- Unary arithmetic operators --
 
-		GLM_FUNC_DECL tmat4x3<T, P> & operator=(tmat4x3<T, P> const & m) GLM_DEFAULT;
+		GLM_FUNC_DECL mat<4, 3, T, P> & operator=(mat<4, 3, T, P> const & m) GLM_DEFAULT;
 
-		template <typename U>
-		GLM_FUNC_DECL tmat4x3<T, P> & operator=(tmat4x3<U, P> const & m);
-		template <typename U>
-		GLM_FUNC_DECL tmat4x3<T, P> & operator+=(U s);
-		template <typename U>
-		GLM_FUNC_DECL tmat4x3<T, P> & operator+=(tmat4x3<U, P> const & m);
-		template <typename U>
-		GLM_FUNC_DECL tmat4x3<T, P> & operator-=(U s);
-		template <typename U>
-		GLM_FUNC_DECL tmat4x3<T, P> & operator-=(tmat4x3<U, P> const & m);
-		template <typename U>
-		GLM_FUNC_DECL tmat4x3<T, P> & operator*=(U s);
-		template <typename U>
-		GLM_FUNC_DECL tmat4x3<T, P> & operator/=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<4, 3, T, P> & operator=(mat<4, 3, U, P> const & m);
+		template<typename U>
+		GLM_FUNC_DECL mat<4, 3, T, P> & operator+=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<4, 3, T, P> & operator+=(mat<4, 3, U, P> const & m);
+		template<typename U>
+		GLM_FUNC_DECL mat<4, 3, T, P> & operator-=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<4, 3, T, P> & operator-=(mat<4, 3, U, P> const & m);
+		template<typename U>
+		GLM_FUNC_DECL mat<4, 3, T, P> & operator*=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<4, 3, T, P> & operator/=(U s);
 
 		// -- Increment and decrement operators --
 
-		GLM_FUNC_DECL tmat4x3<T, P> & operator++();
-		GLM_FUNC_DECL tmat4x3<T, P> & operator--();
-		GLM_FUNC_DECL tmat4x3<T, P> operator++(int);
-		GLM_FUNC_DECL tmat4x3<T, P> operator--(int);
+		GLM_FUNC_DECL mat<4, 3, T, P>& operator++();
+		GLM_FUNC_DECL mat<4, 3, T, P>& operator--();
+		GLM_FUNC_DECL mat<4, 3, T, P> operator++(int);
+		GLM_FUNC_DECL mat<4, 3, T, P> operator--(int);
 	};
 
 	// -- Unary operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat4x3<T, P> operator+(tmat4x3<T, P> const & m);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<4, 3, T, P> operator+(mat<4, 3, T, P> const & m);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat4x3<T, P> operator-(tmat4x3<T, P> const & m);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<4, 3, T, P> operator-(mat<4, 3, T, P> const & m);
 
 	// -- Binary operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat4x3<T, P> operator+(tmat4x3<T, P> const & m, T const & s);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<4, 3, T, P> operator+(mat<4, 3, T, P> const & m, T const & s);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat4x3<T, P> operator+(tmat4x3<T, P> const & m1, tmat4x3<T, P> const & m2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<4, 3, T, P> operator+(mat<4, 3, T, P> const & m1, mat<4, 3, T, P> const & m2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat4x3<T, P> operator-(tmat4x3<T, P> const & m, T const & s);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<4, 3, T, P> operator-(mat<4, 3, T, P> const & m, T const & s);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat4x3<T, P> operator-(tmat4x3<T, P> const & m1, tmat4x3<T, P> const & m2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<4, 3, T, P> operator-(mat<4, 3, T, P> const & m1, mat<4, 3, T, P> const & m2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat4x3<T, P> operator*(tmat4x3<T, P> const & m, T const & s);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<4, 3, T, P> operator*(mat<4, 3, T, P> const & m, T const & s);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat4x3<T, P> operator*(T const & s, tmat4x3<T, P> const & m);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<4, 3, T, P> operator*(T const & s, mat<4, 3, T, P> const & m);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL typename tmat4x3<T, P>::col_type operator*(tmat4x3<T, P> const & m, typename tmat4x3<T, P>::row_type const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL typename mat<4, 3, T, P>::col_type operator*(mat<4, 3, T, P> const & m, typename mat<4, 3, T, P>::row_type const & v);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL typename tmat4x3<T, P>::row_type operator*(typename tmat4x3<T, P>::col_type const & v, tmat4x3<T, P> const & m);
+	template<typename T, precision P>
+	GLM_FUNC_DECL typename mat<4, 3, T, P>::row_type operator*(typename mat<4, 3, T, P>::col_type const & v, mat<4, 3, T, P> const & m);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x3<T, P> operator*(tmat4x3<T, P> const & m1, tmat2x4<T, P> const & m2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<2, 3, T, P> operator*(mat<4, 3, T, P> const & m1, mat<2, 4, T, P> const & m2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat3x3<T, P> operator*(tmat4x3<T, P> const & m1,	tmat3x4<T, P> const & m2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<3, 3, T, P> operator*(mat<4, 3, T, P> const & m1,	mat<3, 4, T, P> const& m2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat4x3<T, P> operator*(tmat4x3<T, P> const & m1, tmat4x4<T, P> const & m2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<4, 3, T, P> operator*(mat<4, 3, T, P> const & m1, mat<4, 4, T, P> const & m2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat4x3<T, P> operator/(tmat4x3<T, P> const & m, T const & s);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<4, 3, T, P> operator/(mat<4, 3, T, P> const & m, T const & s);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat4x3<T, P> operator/(T const & s, tmat4x3<T, P> const & m);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<4, 3, T, P> operator/(T const & s, mat<4, 3, T, P> const & m);
 
 	// -- Boolean operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL bool operator==(tmat4x3<T, P> const & m1, tmat4x3<T, P> const & m2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL bool operator==(mat<4, 3, T, P> const & m1, mat<4, 3, T, P> const & m2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL bool operator!=(tmat4x3<T, P> const & m1, tmat4x3<T, P> const & m2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL bool operator!=(mat<4, 3, T, P> const & m1, mat<4, 3, T, P> const & m2);
 }//namespace glm
 
 #ifndef GLM_EXTERNAL_TEMPLATE
diff --git a/glm/detail/type_mat4x3.inl b/glm/detail/type_mat4x3.inl
index cfb408b3..b3c8d87e 100644
--- a/glm/detail/type_mat4x3.inl
+++ b/glm/detail/type_mat4x3.inl
@@ -6,8 +6,8 @@ namespace glm
 	// -- Constructors --
 
 #	if !GLM_HAS_DEFAULTED_FUNCTIONS || !defined(GLM_FORCE_NO_CTOR_INIT)
-		template <typename T, precision P>
-		GLM_FUNC_QUALIFIER tmat4x3<T, P>::tmat4x3()
+		template<typename T, precision P>
+		GLM_FUNC_QUALIFIER mat<4, 3, T, P>::mat()
 		{
 #			ifndef GLM_FORCE_NO_CTOR_INIT 
 				this->value[0] = col_type(1, 0, 0);
@@ -19,8 +19,8 @@ namespace glm
 #	endif
 
 #	if !GLM_HAS_DEFAULTED_FUNCTIONS
-		template <typename T, precision P>
-		GLM_FUNC_QUALIFIER tmat4x3<T, P>::tmat4x3(tmat4x3<T, P> const & m)
+		template<typename T, precision P>
+		GLM_FUNC_QUALIFIER mat<4, 3, T, P>::mat(mat<4, 3, T, P> const & m)
 		{
 			this->value[0] = m.value[0];
 			this->value[1] = m.value[1];
@@ -29,9 +29,9 @@ namespace glm
 		}
 #	endif//!GLM_HAS_DEFAULTED_FUNCTIONS
 
-	template <typename T, precision P>
-	template <precision Q>
-	GLM_FUNC_QUALIFIER tmat4x3<T, P>::tmat4x3(tmat4x3<T, Q> const & m)
+	template<typename T, precision P>
+	template<precision Q>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, P>::mat(mat<4, 3, T, Q> const & m)
 	{
 		this->value[0] = m.value[0];
 		this->value[1] = m.value[1];
@@ -39,12 +39,12 @@ namespace glm
 		this->value[3] = m.value[3];
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR tmat4x3<T, P>::tmat4x3(ctor)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR mat<4, 3, T, P>::mat(ctor)
 	{}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x3<T, P>::tmat4x3(T const & s)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, P>::mat(T const & s)
 	{
 		this->value[0] = col_type(s, 0, 0);
 		this->value[1] = col_type(0, s, 0);
@@ -52,8 +52,8 @@ namespace glm
 		this->value[3] = col_type(0, 0, 0);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x3<T, P>::tmat4x3
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, P>::mat
 	(
 		T const & x0, T const & y0, T const & z0,
 		T const & x1, T const & y1, T const & z1,
@@ -67,8 +67,8 @@ namespace glm
 		this->value[3] = col_type(x3, y3, z3);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x3<T, P>::tmat4x3
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, P>::mat
 	(
 		col_type const & v0,
 		col_type const & v1,
@@ -84,13 +84,13 @@ namespace glm
 
 	// -- Conversion constructors --
 
-	template <typename T, precision P>
-	template <
+	template<typename T, precision P>
+	template<
 		typename X1, typename Y1, typename Z1,
 		typename X2, typename Y2, typename Z2,
 		typename X3, typename Y3, typename Z3,
 		typename X4, typename Y4, typename Z4>
-	GLM_FUNC_QUALIFIER tmat4x3<T, P>::tmat4x3
+	GLM_FUNC_QUALIFIER mat<4, 3, T, P>::mat
 	(
 		X1 const & x1, Y1 const & y1, Z1 const & z1,
 		X2 const & x2, Y2 const & y2, Z2 const & z2,
@@ -104,14 +104,14 @@ namespace glm
 		this->value[3] = col_type(static_cast<T>(x4), value_type(y4), value_type(z4));
 	}
 	
-	template <typename T, precision P>
-	template <typename V1, typename V2, typename V3, typename V4>
-	GLM_FUNC_QUALIFIER tmat4x3<T, P>::tmat4x3
+	template<typename T, precision P>
+	template<typename V1, typename V2, typename V3, typename V4>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, P>::mat
 	(
-		tvec3<V1, P> const & v1,
-		tvec3<V2, P> const & v2,
-		tvec3<V3, P> const & v3,
-		tvec3<V4, P> const & v4
+		vec<3, V1, P> const & v1,
+		vec<3, V2, P> const & v2,
+		vec<3, V3, P> const & v3,
+		vec<3, V4, P> const & v4
 	)
 	{
 		this->value[0] = col_type(v1);
@@ -122,9 +122,9 @@ namespace glm
 
 	// -- Matrix conversions --
 
-	template <typename T, precision P>
-	template <typename U, precision Q>
-	GLM_FUNC_QUALIFIER tmat4x3<T, P>::tmat4x3(tmat4x3<U, Q> const & m)
+	template<typename T, precision P>
+	template<typename U, precision Q>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, P>::mat(mat<4, 3, U, Q> const & m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
@@ -132,8 +132,8 @@ namespace glm
 		this->value[3] = col_type(m[3]);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x3<T, P>::tmat4x3(tmat2x2<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, P>::mat(mat<2, 2, T, P> const & m)
 	{
 		this->value[0] = col_type(m[0], 0);
 		this->value[1] = col_type(m[1], 0);
@@ -141,8 +141,8 @@ namespace glm
 		this->value[3] = col_type(0);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x3<T, P>::tmat4x3(tmat3x3<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, P>::mat(mat<3, 3, T, P> const & m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
@@ -150,8 +150,8 @@ namespace glm
 		this->value[3] = col_type(0);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x3<T, P>::tmat4x3(tmat4x4<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, P>::mat(mat<4, 4, T, P> const & m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
@@ -159,8 +159,8 @@ namespace glm
 		this->value[3] = col_type(m[3]);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x3<T, P>::tmat4x3(tmat2x3<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, P>::mat(mat<2, 3, T, P> const & m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
@@ -168,8 +168,8 @@ namespace glm
 		this->value[3] = col_type(0);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x3<T, P>::tmat4x3(tmat3x2<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, P>::mat(mat<3, 2, T, P> const & m)
 	{
 		this->value[0] = col_type(m[0], 0);
 		this->value[1] = col_type(m[1], 0);
@@ -177,8 +177,8 @@ namespace glm
 		this->value[3] = col_type(0);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x3<T, P>::tmat4x3(tmat2x4<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, P>::mat(mat<2, 4, T, P> const & m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
@@ -186,8 +186,8 @@ namespace glm
 		this->value[3] = col_type(0);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x3<T, P>::tmat4x3(tmat4x2<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, P>::mat(mat<4, 2, T, P> const & m)
 	{
 		this->value[0] = col_type(m[0], 0);
 		this->value[1] = col_type(m[1], 0);
@@ -195,8 +195,8 @@ namespace glm
 		this->value[3] = col_type(m[3], 0);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x3<T, P>::tmat4x3(tmat3x4<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, P>::mat(mat<3, 4, T, P> const & m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
@@ -206,15 +206,15 @@ namespace glm
 
 	// -- Accesses --
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER typename tmat4x3<T, P>::col_type & tmat4x3<T, P>::operator[](typename tmat4x3<T, P>::length_type i)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER typename mat<4, 3, T, P>::col_type & mat<4, 3, T, P>::operator[](typename mat<4, 3, T, P>::length_type i)
 	{
 		assert(i < this->length());
 		return this->value[i];
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER typename tmat4x3<T, P>::col_type const & tmat4x3<T, P>::operator[](typename tmat4x3<T, P>::length_type i) const
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER typename mat<4, 3, T, P>::col_type const & mat<4, 3, T, P>::operator[](typename mat<4, 3, T, P>::length_type i) const
 	{
 		assert(i < this->length());
 		return this->value[i];
@@ -223,8 +223,8 @@ namespace glm
 	// -- Unary updatable operators --
 
 #	if !GLM_HAS_DEFAULTED_FUNCTIONS
-		template <typename T, precision P>
-		GLM_FUNC_QUALIFIER tmat4x3<T, P>& tmat4x3<T, P>::operator=(tmat4x3<T, P> const & m)
+		template<typename T, precision P>
+		GLM_FUNC_QUALIFIER mat<4, 3, T, P>& mat<4, 3, T, P>::operator=(mat<4, 3, T, P> const & m)
 		{
 			this->value[0] = m[0];
 			this->value[1] = m[1];
@@ -234,9 +234,9 @@ namespace glm
 		}
 #	endif//!GLM_HAS_DEFAULTED_FUNCTIONS
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat4x3<T, P>& tmat4x3<T, P>::operator=(tmat4x3<U, P> const & m)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, P>& mat<4, 3, T, P>::operator=(mat<4, 3, U, P> const & m)
 	{
 		this->value[0] = m[0];
 		this->value[1] = m[1];
@@ -245,9 +245,9 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat4x3<T, P> & tmat4x3<T, P>::operator+=(U s)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, P> & mat<4, 3, T, P>::operator+=(U s)
 	{
 		this->value[0] += s;
 		this->value[1] += s;
@@ -256,9 +256,9 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat4x3<T, P> & tmat4x3<T, P>::operator+=(tmat4x3<U, P> const & m)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, P> & mat<4, 3, T, P>::operator+=(mat<4, 3, U, P> const & m)
 	{
 		this->value[0] += m[0];
 		this->value[1] += m[1];
@@ -267,9 +267,9 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat4x3<T, P> & tmat4x3<T, P>::operator-=(U s)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, P> & mat<4, 3, T, P>::operator-=(U s)
 	{
 		this->value[0] -= s;
 		this->value[1] -= s;
@@ -278,9 +278,9 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat4x3<T, P> & tmat4x3<T, P>::operator-=(tmat4x3<U, P> const & m)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, P> & mat<4, 3, T, P>::operator-=(mat<4, 3, U, P> const & m)
 	{
 		this->value[0] -= m[0];
 		this->value[1] -= m[1];
@@ -289,9 +289,9 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat4x3<T, P> & tmat4x3<T, P>::operator*=(U s)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, P> & mat<4, 3, T, P>::operator*=(U s)
 	{
 		this->value[0] *= s;
 		this->value[1] *= s;
@@ -300,9 +300,9 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat4x3<T, P> & tmat4x3<T, P>::operator/=(U s)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, P> & mat<4, 3, T, P>::operator/=(U s)
 	{
 		this->value[0] /= s;
 		this->value[1] /= s;
@@ -313,8 +313,8 @@ namespace glm
 
 	// -- Increment and decrement operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x3<T, P> & tmat4x3<T, P>::operator++()
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, P> & mat<4, 3, T, P>::operator++()
 	{
 		++this->value[0];
 		++this->value[1];
@@ -323,8 +323,8 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x3<T, P> & tmat4x3<T, P>::operator--()
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, P> & mat<4, 3, T, P>::operator--()
 	{
 		--this->value[0];
 		--this->value[1];
@@ -333,34 +333,34 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x3<T, P> tmat4x3<T, P>::operator++(int)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, P> mat<4, 3, T, P>::operator++(int)
 	{
-		tmat4x3<T, P> Result(*this);
+		mat<4, 3, T, P> Result(*this);
 		++*this;
 		return Result;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x3<T, P> tmat4x3<T, P>::operator--(int)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, P> mat<4, 3, T, P>::operator--(int)
 	{
-		tmat4x3<T, P> Result(*this);
+		mat<4, 3, T, P> Result(*this);
 		--*this;
 		return Result;
 	}
 
 	// -- Unary arithmetic operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x3<T, P> operator+(tmat4x3<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, P> operator+(mat<4, 3, T, P> const & m)
 	{
 		return m;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x3<T, P> operator-(tmat4x3<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, P> operator-(mat<4, 3, T, P> const & m)
 	{
-		return tmat4x3<T, P>(
+		return mat<4, 3, T, P>(
 			-m[0],
 			-m[1],
 			-m[2],
@@ -369,95 +369,95 @@ namespace glm
 
 	// -- Binary arithmetic operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x3<T, P> operator+(tmat4x3<T, P> const & m, T const & s)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, P> operator+(mat<4, 3, T, P> const & m, T const & s)
 	{
-		return tmat4x3<T, P>(
+		return mat<4, 3, T, P>(
 			m[0] + s,
 			m[1] + s,
 			m[2] + s,
 			m[3] + s);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x3<T, P> operator+(tmat4x3<T, P> const & m1, tmat4x3<T, P> const & m2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, P> operator+(mat<4, 3, T, P> const & m1, mat<4, 3, T, P> const & m2)
 	{
-		return tmat4x3<T, P>(
+		return mat<4, 3, T, P>(
 			m1[0] + m2[0],
 			m1[1] + m2[1],
 			m1[2] + m2[2],
 			m1[3] + m2[3]);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x3<T, P> operator-(tmat4x3<T, P> const & m, T const & s)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, P> operator-(mat<4, 3, T, P> const & m, T const & s)
 	{
-		return tmat4x3<T, P>(
+		return mat<4, 3, T, P>(
 			m[0] - s,
 			m[1] - s,
 			m[2] - s,
 			m[3] - s);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x3<T, P> operator-(tmat4x3<T, P> const & m1, tmat4x3<T, P> const & m2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, P> operator-(mat<4, 3, T, P> const & m1, mat<4, 3, T, P> const & m2)
 	{
-		return tmat4x3<T, P>(
+		return mat<4, 3, T, P>(
 			m1[0] - m2[0],
 			m1[1] - m2[1],
 			m1[2] - m2[2],
 			m1[3] - m2[3]);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x3<T, P> operator*(tmat4x3<T, P> const & m, T const & s)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, P> operator*(mat<4, 3, T, P> const & m, T const & s)
 	{
-		return tmat4x3<T, P>(
+		return mat<4, 3, T, P>(
 			m[0] * s,
 			m[1] * s,
 			m[2] * s,
 			m[3] * s);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x3<T, P> operator*(T const & s, tmat4x3<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, P> operator*(T const & s, mat<4, 3, T, P> const & m)
 	{
-		return tmat4x3<T, P>(
+		return mat<4, 3, T, P>(
 			m[0] * s,
 			m[1] * s,
 			m[2] * s,
 			m[3] * s);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER typename tmat4x3<T, P>::col_type operator*
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER typename mat<4, 3, T, P>::col_type operator*
 	(
-		tmat4x3<T, P> const & m,
-		typename tmat4x3<T, P>::row_type const & v)
+		mat<4, 3, T, P> const& m,
+		typename mat<4, 3, T, P>::row_type const & v)
 	{
-		return typename tmat4x3<T, P>::col_type(
+		return typename mat<4, 3, T, P>::col_type(
 			m[0][0] * v.x + m[1][0] * v.y + m[2][0] * v.z + m[3][0] * v.w,
 			m[0][1] * v.x + m[1][1] * v.y + m[2][1] * v.z + m[3][1] * v.w,
 			m[0][2] * v.x + m[1][2] * v.y + m[2][2] * v.z + m[3][2] * v.w);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER typename tmat4x3<T, P>::row_type operator*
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER typename mat<4, 3, T, P>::row_type operator*
 	(
-		typename tmat4x3<T, P>::col_type const & v,
-		tmat4x3<T, P> const & m)
+		typename mat<4, 3, T, P>::col_type const & v,
+		mat<4, 3, T, P> const& m)
 	{
-		return typename tmat4x3<T, P>::row_type(
+		return typename mat<4, 3, T, P>::row_type(
 			v.x * m[0][0] + v.y * m[0][1] + v.z * m[0][2],
 			v.x * m[1][0] + v.y * m[1][1] + v.z * m[1][2],
 			v.x * m[2][0] + v.y * m[2][1] + v.z * m[2][2],
 			v.x * m[3][0] + v.y * m[3][1] + v.z * m[3][2]);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x3<T, P> operator*(tmat4x3<T, P> const & m1, tmat2x4<T, P> const & m2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<2, 3, T, P> operator*(mat<4, 3, T, P> const & m1, mat<2, 4, T, P> const & m2)
 	{
-		return tmat2x3<T, P>(
+		return mat<2, 3, T, P>(
 			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2] + m1[3][0] * m2[0][3],
 			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2] + m1[3][1] * m2[0][3],
 			m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1] + m1[2][2] * m2[0][2] + m1[3][2] * m2[0][3],
@@ -466,8 +466,8 @@ namespace glm
 			m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1] + m1[2][2] * m2[1][2] + m1[3][2] * m2[1][3]);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x3<T, P> operator*(tmat4x3<T, P> const & m1, tmat3x4<T, P> const & m2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, P> operator*(mat<4, 3, T, P> const & m1, mat<3, 4, T, P> const & m2)
 	{
 		T const SrcA00 = m1[0][0];
 		T const SrcA01 = m1[0][1];
@@ -495,7 +495,7 @@ namespace glm
 		T const SrcB22 = m2[2][2];
 		T const SrcB23 = m2[2][3];
 
-		tmat3x3<T, P> Result(uninitialize);
+		mat<3, 3, T, P> Result(uninitialize);
 		Result[0][0] = SrcA00 * SrcB00 + SrcA10 * SrcB01 + SrcA20 * SrcB02 + SrcA30 * SrcB03;
 		Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01 + SrcA21 * SrcB02 + SrcA31 * SrcB03;
 		Result[0][2] = SrcA02 * SrcB00 + SrcA12 * SrcB01 + SrcA22 * SrcB02 + SrcA32 * SrcB03;
@@ -508,10 +508,10 @@ namespace glm
 		return Result;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x3<T, P> operator*(tmat4x3<T, P> const & m1, tmat4x4<T, P> const & m2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, P> operator*(mat<4, 3, T, P> const & m1, mat<4, 4, T, P> const & m2)
 	{
-		return tmat4x3<T, P>(
+		return mat<4, 3, T, P>(
 			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2] + m1[3][0] * m2[0][3],
 			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2] + m1[3][1] * m2[0][3],
 			m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1] + m1[2][2] * m2[0][2] + m1[3][2] * m2[0][3],
@@ -526,20 +526,20 @@ namespace glm
 			m1[0][2] * m2[3][0] + m1[1][2] * m2[3][1] + m1[2][2] * m2[3][2] + m1[3][2] * m2[3][3]);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x3<T, P> operator/(tmat4x3<T, P> const & m, T const & s)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, P> operator/(mat<4, 3, T, P> const & m, T const & s)
 	{
-		return tmat4x3<T, P>(
+		return mat<4, 3, T, P>(
 			m[0] / s,
 			m[1] / s,
 			m[2] / s,
 			m[3] / s);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x3<T, P> operator/(T const & s, tmat4x3<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, P> operator/(T const & s, mat<4, 3, T, P> const & m)
 	{
-		return tmat4x3<T, P>(
+		return mat<4, 3, T, P>(
 			s / m[0],
 			s / m[1],
 			s / m[2],
@@ -548,14 +548,14 @@ namespace glm
 
 	// -- Boolean operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER bool operator==(tmat4x3<T, P> const & m1, tmat4x3<T, P> const & m2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER bool operator==(mat<4, 3, T, P> const & m1, mat<4, 3, T, P> const & m2)
 	{
 		return (m1[0] == m2[0]) && (m1[1] == m2[1]) && (m1[2] == m2[2]) && (m1[3] == m2[3]);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER bool operator!=(tmat4x3<T, P> const & m1, tmat4x3<T, P> const & m2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER bool operator!=(mat<4, 3, T, P> const & m1, mat<4, 3, T, P> const & m2)
 	{
 		return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]) || (m1[3] != m2[3]);
 	}
diff --git a/glm/detail/type_mat4x4.hpp b/glm/detail/type_mat4x4.hpp
index 2222d10e..e0d109ac 100644
--- a/glm/detail/type_mat4x4.hpp
+++ b/glm/detail/type_mat4x4.hpp
@@ -11,73 +11,19 @@
 
 namespace glm
 {
-	template <typename T, precision P = defaultp>
-	struct tmat4x4
+	template<typename T, precision P>
+	struct mat<4, 4, T, P>
 	{
-		typedef tvec4<T, P> col_type;
-		typedef tvec4<T, P> row_type;
-		typedef tmat4x4<T, P> type;
-		typedef tmat4x4<T, P> transpose_type;
+		typedef vec<4, T, P> col_type;
+		typedef vec<4, T, P> row_type;
+		typedef mat<4, 4, T, P> type;
+		typedef mat<4, 4, T, P> transpose_type;
 		typedef T value_type;
 
 	private:
 		col_type value[4];
 
 	public:
-		// -- Constructors --
-
-		GLM_FUNC_DECL tmat4x4() GLM_DEFAULT_CTOR;
-		GLM_FUNC_DECL tmat4x4(tmat4x4<T, P> const & m) GLM_DEFAULT;
-		template <precision Q>
-		GLM_FUNC_DECL tmat4x4(tmat4x4<T, Q> const & m);
-
-		GLM_FUNC_DECL explicit tmat4x4(ctor);
-		GLM_FUNC_DECL explicit tmat4x4(T const & x);
-		GLM_FUNC_DECL tmat4x4(
-			T const & x0, T const & y0, T const & z0, T const & w0,
-			T const & x1, T const & y1, T const & z1, T const & w1,
-			T const & x2, T const & y2, T const & z2, T const & w2,
-			T const & x3, T const & y3, T const & z3, T const & w3);
-		GLM_FUNC_DECL tmat4x4(
-			col_type const & v0,
-			col_type const & v1,
-			col_type const & v2,
-			col_type const & v3);
-
-		// -- Conversions --
-
-		template <
-			typename X1, typename Y1, typename Z1, typename W1,
-			typename X2, typename Y2, typename Z2, typename W2,
-			typename X3, typename Y3, typename Z3, typename W3,
-			typename X4, typename Y4, typename Z4, typename W4>
-		GLM_FUNC_DECL tmat4x4(
-			X1 const & x1, Y1 const & y1, Z1 const & z1, W1 const & w1,
-			X2 const & x2, Y2 const & y2, Z2 const & z2, W2 const & w2,
-			X3 const & x3, Y3 const & y3, Z3 const & z3, W3 const & w3,
-			X4 const & x4, Y4 const & y4, Z4 const & z4, W4 const & w4);
-
-		template <typename V1, typename V2, typename V3, typename V4>
-		GLM_FUNC_DECL tmat4x4(
-			tvec4<V1, P> const & v1,
-			tvec4<V2, P> const & v2,
-			tvec4<V3, P> const & v3,
-			tvec4<V4, P> const & v4);
-
-		// -- Matrix conversions --
-
-		template <typename U, precision Q>
-		GLM_FUNC_DECL GLM_EXPLICIT tmat4x4(tmat4x4<U, Q> const & m);
-
-		GLM_FUNC_DECL GLM_EXPLICIT tmat4x4(tmat2x2<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat4x4(tmat3x3<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat4x4(tmat2x3<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat4x4(tmat3x2<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat4x4(tmat2x4<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat4x4(tmat4x2<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat4x4(tmat3x4<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat4x4(tmat4x3<T, P> const & x);
-
 		// -- Accesses --
 
 		typedef length_t length_type;
@@ -86,108 +32,162 @@ namespace glm
 		GLM_FUNC_DECL col_type & operator[](length_type i);
 		GLM_FUNC_DECL col_type const & operator[](length_type i) const;
 
+		// -- Constructors --
+
+		GLM_FUNC_DECL mat() GLM_DEFAULT_CTOR;
+		GLM_FUNC_DECL mat(mat<4, 4, T, P> const& m) GLM_DEFAULT;
+		template<precision Q>
+		GLM_FUNC_DECL mat(mat<4, 4, T, Q> const& m);
+
+		GLM_FUNC_DECL explicit mat(ctor);
+		GLM_FUNC_DECL explicit mat(T const & x);
+		GLM_FUNC_DECL mat(
+			T const & x0, T const & y0, T const & z0, T const & w0,
+			T const & x1, T const & y1, T const & z1, T const & w1,
+			T const & x2, T const & y2, T const & z2, T const & w2,
+			T const & x3, T const & y3, T const & z3, T const & w3);
+		GLM_FUNC_DECL mat(
+			col_type const & v0,
+			col_type const & v1,
+			col_type const & v2,
+			col_type const & v3);
+
+		// -- Conversions --
+
+		template<
+			typename X1, typename Y1, typename Z1, typename W1,
+			typename X2, typename Y2, typename Z2, typename W2,
+			typename X3, typename Y3, typename Z3, typename W3,
+			typename X4, typename Y4, typename Z4, typename W4>
+		GLM_FUNC_DECL mat(
+			X1 const & x1, Y1 const & y1, Z1 const & z1, W1 const & w1,
+			X2 const & x2, Y2 const & y2, Z2 const & z2, W2 const & w2,
+			X3 const & x3, Y3 const & y3, Z3 const & z3, W3 const & w3,
+			X4 const & x4, Y4 const & y4, Z4 const & z4, W4 const & w4);
+
+		template<typename V1, typename V2, typename V3, typename V4>
+		GLM_FUNC_DECL mat(
+			vec<4, V1, P> const & v1,
+			vec<4, V2, P> const & v2,
+			vec<4, V3, P> const & v3,
+			vec<4, V4, P> const & v4);
+
+		// -- Matrix conversions --
+
+		template<typename U, precision Q>
+		GLM_FUNC_DECL GLM_EXPLICIT mat(mat<4, 4, U, Q> const & m);
+
+		GLM_FUNC_DECL GLM_EXPLICIT mat(mat<2, 2, T, P> const & x);
+		GLM_FUNC_DECL GLM_EXPLICIT mat(mat<3, 3, T, P> const & x);
+		GLM_FUNC_DECL GLM_EXPLICIT mat(mat<2, 3, T, P> const & x);
+		GLM_FUNC_DECL GLM_EXPLICIT mat(mat<3, 2, T, P> const & x);
+		GLM_FUNC_DECL GLM_EXPLICIT mat(mat<2, 4, T, P> const & x);
+		GLM_FUNC_DECL GLM_EXPLICIT mat(mat<4, 2, T, P> const & x);
+		GLM_FUNC_DECL GLM_EXPLICIT mat(mat<3, 4, T, P> const & x);
+		GLM_FUNC_DECL GLM_EXPLICIT mat(mat<4, 3, T, P> const & x);
+
 		// -- Unary arithmetic operators --
 
-		GLM_FUNC_DECL tmat4x4<T, P> & operator=(tmat4x4<T, P> const & m) GLM_DEFAULT;
+		GLM_FUNC_DECL mat<4, 4, T, P> & operator=(mat<4, 4, T, P> const & m) GLM_DEFAULT;
 
-		template <typename U>
-		GLM_FUNC_DECL tmat4x4<T, P> & operator=(tmat4x4<U, P> const & m);
-		template <typename U>
-		GLM_FUNC_DECL tmat4x4<T, P> & operator+=(U s);
-		template <typename U>
-		GLM_FUNC_DECL tmat4x4<T, P> & operator+=(tmat4x4<U, P> const & m);
-		template <typename U>
-		GLM_FUNC_DECL tmat4x4<T, P> & operator-=(U s);
-		template <typename U>
-		GLM_FUNC_DECL tmat4x4<T, P> & operator-=(tmat4x4<U, P> const & m);
-		template <typename U>
-		GLM_FUNC_DECL tmat4x4<T, P> & operator*=(U s);
-		template <typename U>
-		GLM_FUNC_DECL tmat4x4<T, P> & operator*=(tmat4x4<U, P> const & m);
-		template <typename U>
-		GLM_FUNC_DECL tmat4x4<T, P> & operator/=(U s);
-		template <typename U>
-		GLM_FUNC_DECL tmat4x4<T, P> & operator/=(tmat4x4<U, P> const & m);
+		template<typename U>
+		GLM_FUNC_DECL mat<4, 4, T, P> & operator=(mat<4, 4, U, P> const & m);
+		template<typename U>
+		GLM_FUNC_DECL mat<4, 4, T, P> & operator+=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<4, 4, T, P> & operator+=(mat<4, 4, U, P> const & m);
+		template<typename U>
+		GLM_FUNC_DECL mat<4, 4, T, P> & operator-=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<4, 4, T, P> & operator-=(mat<4, 4, U, P> const & m);
+		template<typename U>
+		GLM_FUNC_DECL mat<4, 4, T, P> & operator*=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<4, 4, T, P> & operator*=(mat<4, 4, U, P> const & m);
+		template<typename U>
+		GLM_FUNC_DECL mat<4, 4, T, P> & operator/=(U s);
+		template<typename U>
+		GLM_FUNC_DECL mat<4, 4, T, P> & operator/=(mat<4, 4, U, P> const & m);
 
 		// -- Increment and decrement operators --
 
-		GLM_FUNC_DECL tmat4x4<T, P> & operator++();
-		GLM_FUNC_DECL tmat4x4<T, P> & operator--();
-		GLM_FUNC_DECL tmat4x4<T, P> operator++(int);
-		GLM_FUNC_DECL tmat4x4<T, P> operator--(int);
+		GLM_FUNC_DECL mat<4, 4, T, P> & operator++();
+		GLM_FUNC_DECL mat<4, 4, T, P> & operator--();
+		GLM_FUNC_DECL mat<4, 4, T, P> operator++(int);
+		GLM_FUNC_DECL mat<4, 4, T, P> operator--(int);
 	};
 
 	// -- Unary operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat4x4<T, P> operator+(tmat4x4<T, P> const & m);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<4, 4, T, P> operator+(mat<4, 4, T, P> const & m);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat4x4<T, P> operator-(tmat4x4<T, P> const & m);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<4, 4, T, P> operator-(mat<4, 4, T, P> const & m);
 
 	// -- Binary operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat4x4<T, P> operator+(tmat4x4<T, P> const & m, T const & s);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<4, 4, T, P> operator+(mat<4, 4, T, P> const & m, T const & s);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat4x4<T, P> operator+(T const & s, tmat4x4<T, P> const & m);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<4, 4, T, P> operator+(T const & s, mat<4, 4, T, P> const & m);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat4x4<T, P> operator+(tmat4x4<T, P> const & m1, tmat4x4<T, P> const & m2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<4, 4, T, P> operator+(mat<4, 4, T, P> const & m1, mat<4, 4, T, P> const & m2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat4x4<T, P> operator-(tmat4x4<T, P> const & m, T const & s);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<4, 4, T, P> operator-(mat<4, 4, T, P> const & m, T const & s);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat4x4<T, P> operator-(T const & s, tmat4x4<T, P> const & m);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<4, 4, T, P> operator-(T const & s, mat<4, 4, T, P> const & m);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat4x4<T, P> operator-(tmat4x4<T, P> const & m1,	tmat4x4<T, P> const & m2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<4, 4, T, P> operator-(mat<4, 4, T, P> const & m1,	mat<4, 4, T, P> const& m2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat4x4<T, P> operator*(tmat4x4<T, P> const & m, T const & s);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<4, 4, T, P> operator*(mat<4, 4, T, P> const & m, T const & s);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat4x4<T, P> operator*(T const & s, tmat4x4<T, P> const & m);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<4, 4, T, P> operator*(T const & s, mat<4, 4, T, P> const & m);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL typename tmat4x4<T, P>::col_type operator*(tmat4x4<T, P> const & m, typename tmat4x4<T, P>::row_type const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL typename mat<4, 4, T, P>::col_type operator*(mat<4, 4, T, P> const & m, typename mat<4, 4, T, P>::row_type const & v);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL typename tmat4x4<T, P>::row_type operator*(typename tmat4x4<T, P>::col_type const & v, tmat4x4<T, P> const & m);
+	template<typename T, precision P>
+	GLM_FUNC_DECL typename mat<4, 4, T, P>::row_type operator*(typename mat<4, 4, T, P>::col_type const & v, mat<4, 4, T, P> const & m);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x4<T, P> operator*(tmat4x4<T, P> const & m1, tmat2x4<T, P> const & m2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<2, 4, T, P> operator*(mat<4, 4, T, P> const & m1, mat<2, 4, T, P> const & m2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat3x4<T, P> operator*(tmat4x4<T, P> const & m1, tmat3x4<T, P> const & m2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<3, 4, T, P> operator*(mat<4, 4, T, P> const & m1, mat<3, 4, T, P> const & m2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat4x4<T, P> operator*(tmat4x4<T, P> const & m1, tmat4x4<T, P> const & m2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<4, 4, T, P> operator*(mat<4, 4, T, P> const & m1, mat<4, 4, T, P> const & m2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat4x4<T, P> operator/(tmat4x4<T, P> const & m, T const & s);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<4, 4, T, P> operator/(mat<4, 4, T, P> const & m, T const & s);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat4x4<T, P> operator/(T const & s, tmat4x4<T, P> const & m);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<4, 4, T, P> operator/(T const & s, mat<4, 4, T, P> const & m);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL typename tmat4x4<T, P>::col_type operator/(tmat4x4<T, P> const & m, typename tmat4x4<T, P>::row_type const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL typename mat<4, 4, T, P>::col_type operator/(mat<4, 4, T, P> const & m, typename mat<4, 4, T, P>::row_type const & v);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL typename tmat4x4<T, P>::row_type operator/(typename tmat4x4<T, P>::col_type const & v, tmat4x4<T, P> const & m);
+	template<typename T, precision P>
+	GLM_FUNC_DECL typename mat<4, 4, T, P>::row_type operator/(typename mat<4, 4, T, P>::col_type const & v, mat<4, 4, T, P> const & m);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat4x4<T, P> operator/(tmat4x4<T, P> const & m1,	tmat4x4<T, P> const & m2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<4, 4, T, P> operator/(mat<4, 4, T, P> const & m1,	mat<4, 4, T, P> const& m2);
 
 	// -- Boolean operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL bool operator==(tmat4x4<T, P> const & m1, tmat4x4<T, P> const & m2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL bool operator==(mat<4, 4, T, P> const & m1, mat<4, 4, T, P> const & m2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL bool operator!=(tmat4x4<T, P> const & m1, tmat4x4<T, P> const & m2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL bool operator!=(mat<4, 4, T, P> const & m1, mat<4, 4, T, P> const & m2);
 }//namespace glm
 
 #ifndef GLM_EXTERNAL_TEMPLATE
diff --git a/glm/detail/type_mat4x4.inl b/glm/detail/type_mat4x4.inl
index 4b75d947..880ce931 100644
--- a/glm/detail/type_mat4x4.inl
+++ b/glm/detail/type_mat4x4.inl
@@ -8,8 +8,8 @@ namespace glm
 	// -- Constructors --
 
 #	if !GLM_HAS_DEFAULTED_FUNCTIONS || !defined(GLM_FORCE_NO_CTOR_INIT)
-		template <typename T, precision P>
-		GLM_FUNC_QUALIFIER tmat4x4<T, P>::tmat4x4()
+		template<typename T, precision P>
+		GLM_FUNC_QUALIFIER mat<4, 4, T, P>::mat()
 		{
 #			ifndef GLM_FORCE_NO_CTOR_INIT 
 				this->value[0] = col_type(1, 0, 0, 0);
@@ -21,8 +21,8 @@ namespace glm
 #	endif
 
 #	if !GLM_HAS_DEFAULTED_FUNCTIONS
-		template <typename T, precision P>
-		GLM_FUNC_QUALIFIER tmat4x4<T, P>::tmat4x4(tmat4x4<T, P> const & m)
+		template<typename T, precision P>
+		GLM_FUNC_QUALIFIER mat<4, 4, T, P>::mat(mat<4, 4, T, P> const & m)
 		{
 			this->value[0] = m[0];
 			this->value[1] = m[1];
@@ -31,9 +31,9 @@ namespace glm
 		}
 #	endif//!GLM_HAS_DEFAULTED_FUNCTIONS
 
-	template <typename T, precision P>
-	template <precision Q>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P>::tmat4x4(tmat4x4<T, Q> const & m)
+	template<typename T, precision P>
+	template<precision Q>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, P>::mat(mat<4, 4, T, Q> const & m)
 	{
 		this->value[0] = m[0];
 		this->value[1] = m[1];
@@ -41,12 +41,12 @@ namespace glm
 		this->value[3] = m[3];
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P>::tmat4x4(ctor)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, P>::mat(ctor)
 	{}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P>::tmat4x4(T const & s)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, P>::mat(T const & s)
 	{
 		this->value[0] = col_type(s, 0, 0, 0);
 		this->value[1] = col_type(0, s, 0, 0);
@@ -54,8 +54,8 @@ namespace glm
 		this->value[3] = col_type(0, 0, 0, s);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P>::tmat4x4
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, P>::mat
 	(
 		T const & x0, T const & y0, T const & z0, T const & w0,
 		T const & x1, T const & y1, T const & z1, T const & w1,
@@ -69,8 +69,8 @@ namespace glm
 		this->value[3] = col_type(x3, y3, z3, w3);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P>::tmat4x4
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, P>::mat
 	(
 		col_type const & v0,
 		col_type const & v1,
@@ -84,11 +84,11 @@ namespace glm
 		this->value[3] = v3;
 	}
 
-	template <typename T, precision P>
-	template <typename U, precision Q>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P>::tmat4x4
+	template<typename T, precision P>
+	template<typename U, precision Q>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, P>::mat
 	(
-		tmat4x4<U, Q> const & m
+		mat<4, 4, U, Q> const & m
 	)
 	{
 		this->value[0] = col_type(m[0]);
@@ -99,13 +99,13 @@ namespace glm
 
 	// -- Conversions --
 
-	template <typename T, precision P> 
-	template <
+	template<typename T, precision P> 
+	template<
 		typename X1, typename Y1, typename Z1, typename W1,
 		typename X2, typename Y2, typename Z2, typename W2,
 		typename X3, typename Y3, typename Z3, typename W3,
 		typename X4, typename Y4, typename Z4, typename W4>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P>::tmat4x4
+	GLM_FUNC_QUALIFIER mat<4, 4, T, P>::mat
 	(
 		X1 const & x1, Y1 const & y1, Z1 const & z1, W1 const & w1,
 		X2 const & x2, Y2 const & y2, Z2 const & z2, W2 const & w2,
@@ -139,14 +139,14 @@ namespace glm
 		this->value[3] = col_type(static_cast<T>(x4), value_type(y4), value_type(z4), value_type(w4));
 	}
 	
-	template <typename T, precision P>
-	template <typename V1, typename V2, typename V3, typename V4>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P>::tmat4x4
+	template<typename T, precision P>
+	template<typename V1, typename V2, typename V3, typename V4>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, P>::mat
 	(
-		tvec4<V1, P> const & v1,
-		tvec4<V2, P> const & v2,
-		tvec4<V3, P> const & v3,
-		tvec4<V4, P> const & v4
+		vec<4, V1, P> const & v1,
+		vec<4, V2, P> const & v2,
+		vec<4, V3, P> const & v3,
+		vec<4, V4, P> const & v4
 	)		
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<V1>::is_iec559 || std::numeric_limits<V1>::is_integer || GLM_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 1st parameter type invalid.");
@@ -162,8 +162,8 @@ namespace glm
 
 	// -- Matrix conversions --
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P>::tmat4x4(tmat2x2<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, P>::mat(mat<2, 2, T, P> const & m)
 	{
 		this->value[0] = col_type(m[0], 0, 0);
 		this->value[1] = col_type(m[1], 0, 0);
@@ -171,8 +171,8 @@ namespace glm
 		this->value[3] = col_type(0, 0, 0, 1);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P>::tmat4x4(tmat3x3<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, P>::mat(mat<3, 3, T, P> const & m)
 	{
 		this->value[0] = col_type(m[0], 0);
 		this->value[1] = col_type(m[1], 0);
@@ -180,8 +180,8 @@ namespace glm
 		this->value[3] = col_type(0, 0, 0, 1);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P>::tmat4x4(tmat2x3<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, P>::mat(mat<2, 3, T, P> const & m)
 	{
 		this->value[0] = col_type(m[0], 0);
 		this->value[1] = col_type(m[1], 0);
@@ -189,8 +189,8 @@ namespace glm
 		this->value[3] = col_type(0, 0, 0, 1);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P>::tmat4x4(tmat3x2<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, P>::mat(mat<3, 2, T, P> const & m)
 	{
 		this->value[0] = col_type(m[0], 0, 0);
 		this->value[1] = col_type(m[1], 0, 0);
@@ -198,8 +198,8 @@ namespace glm
 		this->value[3] = col_type(0, 0, 0, 1);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P>::tmat4x4(tmat2x4<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, P>::mat(mat<2, 4, T, P> const & m)
 	{
 		this->value[0] = m[0];
 		this->value[1] = m[1];
@@ -207,8 +207,8 @@ namespace glm
 		this->value[3] = col_type(0, 0, 0, 1);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P>::tmat4x4(tmat4x2<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, P>::mat(mat<4, 2, T, P> const & m)
 	{
 		this->value[0] = col_type(m[0], 0, 0);
 		this->value[1] = col_type(m[1], 0, 0);
@@ -216,8 +216,8 @@ namespace glm
 		this->value[3] = col_type(0, 0, 0, 1);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P>::tmat4x4(tmat3x4<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, P>::mat(mat<3, 4, T, P> const & m)
 	{
 		this->value[0] = m[0];
 		this->value[1] = m[1];
@@ -225,8 +225,8 @@ namespace glm
 		this->value[3] = col_type(0, 0, 0, 1);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P>::tmat4x4(tmat4x3<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, P>::mat(mat<4, 3, T, P> const & m)
 	{
 		this->value[0] = col_type(m[0], 0);
 		this->value[1] = col_type(m[1], 0);
@@ -236,15 +236,15 @@ namespace glm
 
 	// -- Accesses --
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER typename tmat4x4<T, P>::col_type & tmat4x4<T, P>::operator[](typename tmat4x4<T, P>::length_type i)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER typename mat<4, 4, T, P>::col_type & mat<4, 4, T, P>::operator[](typename mat<4, 4, T, P>::length_type i)
 	{
 		assert(i < this->length());
 		return this->value[i];
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER typename tmat4x4<T, P>::col_type const & tmat4x4<T, P>::operator[](typename tmat4x4<T, P>::length_type i) const
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER typename mat<4, 4, T, P>::col_type const & mat<4, 4, T, P>::operator[](typename mat<4, 4, T, P>::length_type i) const
 	{
 		assert(i < this->length());
 		return this->value[i];
@@ -253,8 +253,8 @@ namespace glm
 	// -- Unary arithmetic operators --
 
 #	if !GLM_HAS_DEFAULTED_FUNCTIONS
-		template <typename T, precision P>
-		GLM_FUNC_QUALIFIER tmat4x4<T, P>& tmat4x4<T, P>::operator=(tmat4x4<T, P> const & m)
+		template<typename T, precision P>
+		GLM_FUNC_QUALIFIER mat<4, 4, T, P>& mat<4, 4, T, P>::operator=(mat<4, 4, T, P> const & m)
 		{
 			//memcpy could be faster
 			//memcpy(&this->value, &m.value, 16 * sizeof(valType));
@@ -266,9 +266,9 @@ namespace glm
 		}
 #	endif//!GLM_HAS_DEFAULTED_FUNCTIONS
 
-	template <typename T, precision P> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat4x4<T, P>& tmat4x4<T, P>::operator=(tmat4x4<U, P> const & m)
+	template<typename T, precision P> 
+	template<typename U> 
+	GLM_FUNC_QUALIFIER mat<4, 4, T, P>& mat<4, 4, T, P>::operator=(mat<4, 4, U, P> const & m)
 	{
 		//memcpy could be faster
 		//memcpy(&this->value, &m.value, 16 * sizeof(valType));
@@ -279,9 +279,9 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P>& tmat4x4<T, P>::operator+=(U s)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, P>& mat<4, 4, T, P>::operator+=(U s)
 	{
 		this->value[0] += s;
 		this->value[1] += s;
@@ -290,9 +290,9 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P>& tmat4x4<T, P>::operator+=(tmat4x4<U, P> const & m)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, P>& mat<4, 4, T, P>::operator+=(mat<4, 4, U, P> const & m)
 	{
 		this->value[0] += m[0];
 		this->value[1] += m[1];
@@ -301,9 +301,9 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> & tmat4x4<T, P>::operator-=(U s)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, P> & mat<4, 4, T, P>::operator-=(U s)
 	{
 		this->value[0] -= s;
 		this->value[1] -= s;
@@ -312,9 +312,9 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> & tmat4x4<T, P>::operator-=(tmat4x4<U, P> const & m)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, P> & mat<4, 4, T, P>::operator-=(mat<4, 4, U, P> const & m)
 	{
 		this->value[0] -= m[0];
 		this->value[1] -= m[1];
@@ -323,9 +323,9 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> & tmat4x4<T, P>::operator*=(U s)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, P> & mat<4, 4, T, P>::operator*=(U s)
 	{
 		this->value[0] *= s;
 		this->value[1] *= s;
@@ -334,16 +334,16 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> & tmat4x4<T, P>::operator*=(tmat4x4<U, P> const & m)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, P> & mat<4, 4, T, P>::operator*=(mat<4, 4, U, P> const & m)
 	{
 		return (*this = *this * m);
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> & tmat4x4<T, P>::operator/=(U s)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, P> & mat<4, 4, T, P>::operator/=(U s)
 	{
 		this->value[0] /= s;
 		this->value[1] /= s;
@@ -352,17 +352,17 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> & tmat4x4<T, P>::operator/=(tmat4x4<U, P> const & m)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, P> & mat<4, 4, T, P>::operator/=(mat<4, 4, U, P> const & m)
 	{
 		return *this *= inverse(m);
 	}
 
 	// -- Increment and decrement operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> & tmat4x4<T, P>::operator++()
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, P> & mat<4, 4, T, P>::operator++()
 	{
 		++this->value[0];
 		++this->value[1];
@@ -371,8 +371,8 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> & tmat4x4<T, P>::operator--()
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, P> & mat<4, 4, T, P>::operator--()
 	{
 		--this->value[0];
 		--this->value[1];
@@ -381,34 +381,34 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> tmat4x4<T, P>::operator++(int)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, P> mat<4, 4, T, P>::operator++(int)
 	{
-		tmat4x4<T, P> Result(*this);
+		mat<4, 4, T, P> Result(*this);
 		++*this;
 		return Result;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> tmat4x4<T, P>::operator--(int)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, P> mat<4, 4, T, P>::operator--(int)
 	{
-		tmat4x4<T, P> Result(*this);
+		mat<4, 4, T, P> Result(*this);
 		--*this;
 		return Result;
 	}
 
 	// -- Unary constant operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> operator+(tmat4x4<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, P> operator+(mat<4, 4, T, P> const & m)
 	{
 		return m;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> operator-(tmat4x4<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, P> operator-(mat<4, 4, T, P> const & m)
 	{
-		return tmat4x4<T, P>(
+		return mat<4, 4, T, P>(
 			-m[0],
 			-m[1],
 			-m[2],
@@ -417,91 +417,91 @@ namespace glm
 
 	// -- Binary arithmetic operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> operator+(tmat4x4<T, P> const & m, T const & s)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, P> operator+(mat<4, 4, T, P> const & m, T const & s)
 	{
-		return tmat4x4<T, P>(
+		return mat<4, 4, T, P>(
 			m[0] + s,
 			m[1] + s,
 			m[2] + s,
 			m[3] + s);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> operator+(T const & s, tmat4x4<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, P> operator+(T const & s, mat<4, 4, T, P> const & m)
 	{
-		return tmat4x4<T, P>(
+		return mat<4, 4, T, P>(
 			m[0] + s,
 			m[1] + s,
 			m[2] + s,
 			m[3] + s);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> operator+(tmat4x4<T, P> const & m1, tmat4x4<T, P> const & m2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, P> operator+(mat<4, 4, T, P> const & m1, mat<4, 4, T, P> const & m2)
 	{
-		return tmat4x4<T, P>(
+		return mat<4, 4, T, P>(
 			m1[0] + m2[0],
 			m1[1] + m2[1],
 			m1[2] + m2[2],
 			m1[3] + m2[3]);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> operator-(tmat4x4<T, P> const & m, T const & s)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, P> operator-(mat<4, 4, T, P> const & m, T const & s)
 	{
-		return tmat4x4<T, P>(
+		return mat<4, 4, T, P>(
 			m[0] - s,
 			m[1] - s,
 			m[2] - s,
 			m[3] - s);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> operator-(T const & s, tmat4x4<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, P> operator-(T const & s, mat<4, 4, T, P> const & m)
 	{
-		return tmat4x4<T, P>(
+		return mat<4, 4, T, P>(
 			s - m[0],
 			s - m[1],
 			s - m[2],
 			s - m[3]);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> operator-(tmat4x4<T, P> const & m1, tmat4x4<T, P> const & m2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, P> operator-(mat<4, 4, T, P> const & m1, mat<4, 4, T, P> const & m2)
 	{
-		return tmat4x4<T, P>(
+		return mat<4, 4, T, P>(
 			m1[0] - m2[0],
 			m1[1] - m2[1],
 			m1[2] - m2[2],
 			m1[3] - m2[3]);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> operator*(tmat4x4<T, P> const & m, T const  & s)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, P> operator*(mat<4, 4, T, P> const & m, T const  & s)
 	{
-		return tmat4x4<T, P>(
+		return mat<4, 4, T, P>(
 			m[0] * s,
 			m[1] * s,
 			m[2] * s,
 			m[3] * s);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> operator*(T const & s, tmat4x4<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, P> operator*(T const & s, mat<4, 4, T, P> const & m)
 	{
-		return tmat4x4<T, P>(
+		return mat<4, 4, T, P>(
 			m[0] * s,
 			m[1] * s,
 			m[2] * s,
 			m[3] * s);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER typename tmat4x4<T, P>::col_type operator*
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER typename mat<4, 4, T, P>::col_type operator*
 	(
-		tmat4x4<T, P> const & m,
-		typename tmat4x4<T, P>::row_type const & v
+		mat<4, 4, T, P> const& m,
+		typename mat<4, 4, T, P>::row_type const & v
 	)
 	{
 /*
@@ -520,24 +520,24 @@ namespace glm
 
 		__m128 a2 = _mm_add_ps(a0, a1);
 
-		return typename tmat4x4<T, P>::col_type(a2);
+		return typename mat<4, 4, T, P>::col_type(a2);
 */
 
-		typename tmat4x4<T, P>::col_type const Mov0(v[0]);
-		typename tmat4x4<T, P>::col_type const Mov1(v[1]);
-		typename tmat4x4<T, P>::col_type const Mul0 = m[0] * Mov0;
-		typename tmat4x4<T, P>::col_type const Mul1 = m[1] * Mov1;
-		typename tmat4x4<T, P>::col_type const Add0 = Mul0 + Mul1;
-		typename tmat4x4<T, P>::col_type const Mov2(v[2]);
-		typename tmat4x4<T, P>::col_type const Mov3(v[3]);
-		typename tmat4x4<T, P>::col_type const Mul2 = m[2] * Mov2;
-		typename tmat4x4<T, P>::col_type const Mul3 = m[3] * Mov3;
-		typename tmat4x4<T, P>::col_type const Add1 = Mul2 + Mul3;
-		typename tmat4x4<T, P>::col_type const Add2 = Add0 + Add1;
+		typename mat<4, 4, T, P>::col_type const Mov0(v[0]);
+		typename mat<4, 4, T, P>::col_type const Mov1(v[1]);
+		typename mat<4, 4, T, P>::col_type const Mul0 = m[0] * Mov0;
+		typename mat<4, 4, T, P>::col_type const Mul1 = m[1] * Mov1;
+		typename mat<4, 4, T, P>::col_type const Add0 = Mul0 + Mul1;
+		typename mat<4, 4, T, P>::col_type const Mov2(v[2]);
+		typename mat<4, 4, T, P>::col_type const Mov3(v[3]);
+		typename mat<4, 4, T, P>::col_type const Mul2 = m[2] * Mov2;
+		typename mat<4, 4, T, P>::col_type const Mul3 = m[3] * Mov3;
+		typename mat<4, 4, T, P>::col_type const Add1 = Mul2 + Mul3;
+		typename mat<4, 4, T, P>::col_type const Add2 = Add0 + Add1;
 		return Add2;
 
 /*
-		return typename tmat4x4<T, P>::col_type(
+		return typename mat<4, 4, T, P>::col_type(
 			m[0][0] * v[0] + m[1][0] * v[1] + m[2][0] * v[2] + m[3][0] * v[3],
 			m[0][1] * v[0] + m[1][1] * v[1] + m[2][1] * v[2] + m[3][1] * v[3],
 			m[0][2] * v[0] + m[1][2] * v[1] + m[2][2] * v[2] + m[3][2] * v[3],
@@ -545,24 +545,24 @@ namespace glm
 */
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER typename tmat4x4<T, P>::row_type operator*
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER typename mat<4, 4, T, P>::row_type operator*
 	(
-		typename tmat4x4<T, P>::col_type const & v,
-		tmat4x4<T, P> const & m
+		typename mat<4, 4, T, P>::col_type const & v,
+		mat<4, 4, T, P> const& m
 	)
 	{
-		return typename tmat4x4<T, P>::row_type(
+		return typename mat<4, 4, T, P>::row_type(
 			m[0][0] * v[0] + m[0][1] * v[1] + m[0][2] * v[2] + m[0][3] * v[3],
 			m[1][0] * v[0] + m[1][1] * v[1] + m[1][2] * v[2] + m[1][3] * v[3],
 			m[2][0] * v[0] + m[2][1] * v[1] + m[2][2] * v[2] + m[2][3] * v[3],
 			m[3][0] * v[0] + m[3][1] * v[1] + m[3][2] * v[2] + m[3][3] * v[3]);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P> operator*(tmat4x4<T, P> const & m1, tmat2x4<T, P> const & m2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, P> operator*(mat<4, 4, T, P> const & m1, mat<2, 4, T, P> const & m2)
 	{
-		return tmat2x4<T, P>(
+		return mat<2, 4, T, P>(
 			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2] + m1[3][0] * m2[0][3],
 			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2] + m1[3][1] * m2[0][3],
 			m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1] + m1[2][2] * m2[0][2] + m1[3][2] * m2[0][3],
@@ -573,10 +573,10 @@ namespace glm
 			m1[0][3] * m2[1][0] + m1[1][3] * m2[1][1] + m1[2][3] * m2[1][2] + m1[3][3] * m2[1][3]);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x4<T, P> operator*(tmat4x4<T, P> const & m1, tmat3x4<T, P> const & m2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, P> operator*(mat<4, 4, T, P> const & m1, mat<3, 4, T, P> const & m2)
 	{
-		return tmat3x4<T, P>(
+		return mat<3, 4, T, P>(
 			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2] + m1[3][0] * m2[0][3],
 			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2] + m1[3][1] * m2[0][3],
 			m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1] + m1[2][2] * m2[0][2] + m1[3][2] * m2[0][3],
@@ -591,20 +591,20 @@ namespace glm
 			m1[0][3] * m2[2][0] + m1[1][3] * m2[2][1] + m1[2][3] * m2[2][2] + m1[3][3] * m2[2][3]);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> operator*(tmat4x4<T, P> const & m1, tmat4x4<T, P> const & m2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, P> operator*(mat<4, 4, T, P> const & m1, mat<4, 4, T, P> const & m2)
 	{
-		typename tmat4x4<T, P>::col_type const SrcA0 = m1[0];
-		typename tmat4x4<T, P>::col_type const SrcA1 = m1[1];
-		typename tmat4x4<T, P>::col_type const SrcA2 = m1[2];
-		typename tmat4x4<T, P>::col_type const SrcA3 = m1[3];
+		typename mat<4, 4, T, P>::col_type const SrcA0 = m1[0];
+		typename mat<4, 4, T, P>::col_type const SrcA1 = m1[1];
+		typename mat<4, 4, T, P>::col_type const SrcA2 = m1[2];
+		typename mat<4, 4, T, P>::col_type const SrcA3 = m1[3];
 
-		typename tmat4x4<T, P>::col_type const SrcB0 = m2[0];
-		typename tmat4x4<T, P>::col_type const SrcB1 = m2[1];
-		typename tmat4x4<T, P>::col_type const SrcB2 = m2[2];
-		typename tmat4x4<T, P>::col_type const SrcB3 = m2[3];
+		typename mat<4, 4, T, P>::col_type const SrcB0 = m2[0];
+		typename mat<4, 4, T, P>::col_type const SrcB1 = m2[1];
+		typename mat<4, 4, T, P>::col_type const SrcB2 = m2[2];
+		typename mat<4, 4, T, P>::col_type const SrcB3 = m2[3];
 
-		tmat4x4<T, P> Result(uninitialize);
+		mat<4, 4, T, P> Result(uninitialize);
 		Result[0] = SrcA0 * SrcB0[0] + SrcA1 * SrcB0[1] + SrcA2 * SrcB0[2] + SrcA3 * SrcB0[3];
 		Result[1] = SrcA0 * SrcB1[0] + SrcA1 * SrcB1[1] + SrcA2 * SrcB1[2] + SrcA3 * SrcB1[3];
 		Result[2] = SrcA0 * SrcB2[0] + SrcA1 * SrcB2[1] + SrcA2 * SrcB2[2] + SrcA3 * SrcB2[3];
@@ -612,55 +612,55 @@ namespace glm
 		return Result;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> operator/(tmat4x4<T, P> const & m, T const & s)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, P> operator/(mat<4, 4, T, P> const & m, T const & s)
 	{
-		return tmat4x4<T, P>(
+		return mat<4, 4, T, P>(
 			m[0] / s,
 			m[1] / s,
 			m[2] / s,
 			m[3] / s);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> operator/(T const & s,	tmat4x4<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, P> operator/(T const & s,	mat<4, 4, T, P> const& m)
 	{
-		return tmat4x4<T, P>(
+		return mat<4, 4, T, P>(
 			s / m[0],
 			s / m[1],
 			s / m[2],
 			s / m[3]);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER typename tmat4x4<T, P>::col_type operator/(tmat4x4<T, P> const & m, typename tmat4x4<T, P>::row_type const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER typename mat<4, 4, T, P>::col_type operator/(mat<4, 4, T, P> const & m, typename mat<4, 4, T, P>::row_type const & v)
 	{
 		return inverse(m) * v;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER typename tmat4x4<T, P>::row_type operator/(typename tmat4x4<T, P>::col_type const & v, tmat4x4<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER typename mat<4, 4, T, P>::row_type operator/(typename mat<4, 4, T, P>::col_type const & v, mat<4, 4, T, P> const & m)
 	{
 		return v * inverse(m);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> operator/(tmat4x4<T, P> const & m1, tmat4x4<T, P> const & m2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, P> operator/(mat<4, 4, T, P> const & m1, mat<4, 4, T, P> const & m2)
 	{
-		tmat4x4<T, P> m1_copy(m1);
+		mat<4, 4, T, P> m1_copy(m1);
 		return m1_copy /= m2;
 	}
 
 	// -- Boolean operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER bool operator==(tmat4x4<T, P> const & m1, tmat4x4<T, P> const & m2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER bool operator==(mat<4, 4, T, P> const & m1, mat<4, 4, T, P> const & m2)
 	{
 		return (m1[0] == m2[0]) && (m1[1] == m2[1]) && (m1[2] == m2[2]) && (m1[3] == m2[3]);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER bool operator!=(tmat4x4<T, P> const & m1, tmat4x4<T, P> const & m2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER bool operator!=(mat<4, 4, T, P> const & m1, mat<4, 4, T, P> const & m2)
 	{
 		return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]) || (m1[3] != m2[3]);
 	}
diff --git a/glm/detail/type_vec.hpp b/glm/detail/type_vec.hpp
index 7849db63..c45a25e5 100644
--- a/glm/detail/type_vec.hpp
+++ b/glm/detail/type_vec.hpp
@@ -9,7 +9,7 @@
 namespace glm{
 namespace detail
 {
-	template <typename T, std::size_t size, bool aligned>
+	template<typename T, std::size_t size, bool aligned>
 	struct storage
 	{
 		typedef struct type {
@@ -18,7 +18,7 @@ namespace detail
 	};
 
 	#define GLM_ALIGNED_STORAGE_TYPE_STRUCT(x) \
-		template <typename T> \
+		template<typename T> \
 		struct storage<T, x, true> { \
 			GLM_ALIGNED_STRUCT(x) type { \
 				uint8 data[x]; \
@@ -34,19 +34,19 @@ namespace detail
 	GLM_ALIGNED_STORAGE_TYPE_STRUCT(64)
 		
 #	if GLM_ARCH & GLM_ARCH_SSE2_BIT
-		template <>
+		template<>
 		struct storage<float, 16, true>
 		{
 			typedef glm_vec4 type;
 		};
 
-		template <>
+		template<>
 		struct storage<int, 16, true>
 		{
 			typedef glm_ivec4 type;
 		};
 
-		template <>
+		template<>
 		struct storage<unsigned int, 16, true>
 		{
 			typedef glm_uvec4 type;
@@ -58,19 +58,19 @@ namespace detail
 			unsigned __int8 data[16];
 		} glm_128;
 
-		template <>
+		template<>
 		struct storage<float, 16, true>
 		{
 			typedef glm_128 type;
 		};
 
-		template <>
+		template<>
 		struct storage<int, 16, true>
 		{
 			typedef glm_128 type;
 		};
 
-		template <>
+		template<>
 		struct storage<unsigned int, 16, true>
 		{
 			typedef glm_128 type;
@@ -79,7 +79,7 @@ namespace detail
 #	endif
 
 #	if (GLM_ARCH & GLM_ARCH_AVX_BIT)
-		template <>
+		template<>
 		struct storage<double, 32, true>
 		{
 			typedef glm_dvec4 type;
@@ -87,13 +87,13 @@ namespace detail
 #	endif
 
 #	if (GLM_ARCH & GLM_ARCH_AVX2_BIT)
-		template <>
+		template<>
 		struct storage<int64, 32, true>
 		{
 			typedef glm_i64vec4 type;
 		};
 
-		template <>
+		template<>
 		struct storage<uint64, 32, true>
 		{
 			typedef glm_u64vec4 type;
@@ -101,26 +101,21 @@ namespace detail
 #	endif
 }//namespace detail
 
-	template <typename T, precision P> struct tvec1;
-	template <typename T, precision P> struct tvec2;
-	template <typename T, precision P> struct tvec3;
-	template <typename T, precision P> struct tvec4;
-
-	typedef tvec1<float, highp>		highp_vec1_t;
-	typedef tvec1<float, mediump>	mediump_vec1_t;
-	typedef tvec1<float, lowp>		lowp_vec1_t;
-	typedef tvec1<double, highp>	highp_dvec1_t;
-	typedef tvec1<double, mediump>	mediump_dvec1_t;
-	typedef tvec1<double, lowp>		lowp_dvec1_t;
-	typedef tvec1<int, highp>		highp_ivec1_t;
-	typedef tvec1<int, mediump>		mediump_ivec1_t;
-	typedef tvec1<int, lowp>		lowp_ivec1_t;
-	typedef tvec1<uint, highp>		highp_uvec1_t;
-	typedef tvec1<uint, mediump>	mediump_uvec1_t;
-	typedef tvec1<uint, lowp>		lowp_uvec1_t;
-	typedef tvec1<bool, highp>		highp_bvec1_t;
-	typedef tvec1<bool, mediump>	mediump_bvec1_t;
-	typedef tvec1<bool, lowp>		lowp_bvec1_t;
+	typedef vec<1, float, highp>		highp_vec1_t;
+	typedef vec<1, float, mediump>	mediump_vec1_t;
+	typedef vec<1, float, lowp>		lowp_vec1_t;
+	typedef vec<1, double, highp>	highp_dvec1_t;
+	typedef vec<1, double, mediump>	mediump_dvec1_t;
+	typedef vec<1, double, lowp>		lowp_dvec1_t;
+	typedef vec<1, int, highp>		highp_ivec1_t;
+	typedef vec<1, int, mediump>		mediump_ivec1_t;
+	typedef vec<1, int, lowp>		lowp_ivec1_t;
+	typedef vec<1, uint, highp>		highp_uvec1_t;
+	typedef vec<1, uint, mediump>	mediump_uvec1_t;
+	typedef vec<1, uint, lowp>		lowp_uvec1_t;
+	typedef vec<1, bool, highp>		highp_bvec1_t;
+	typedef vec<1, bool, mediump>	mediump_bvec1_t;
+	typedef vec<1, bool, lowp>		lowp_bvec1_t;
 
 	/// @addtogroup core_precision
 	/// @{
@@ -130,105 +125,105 @@ namespace detail
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tvec2<float, highp>		highp_vec2;
+	typedef vec<2, float, highp>		highp_vec2;
 
 	/// 2 components vector of medium single-precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tvec2<float, mediump>	mediump_vec2;
+	typedef vec<2, float, mediump>	mediump_vec2;
 
 	/// 2 components vector of low single-precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tvec2<float, lowp>		lowp_vec2;
+	typedef vec<2, float, lowp>		lowp_vec2;
 
 	/// 2 components vector of high double-precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tvec2<double, highp>	highp_dvec2;
+	typedef vec<2, double, highp>	highp_dvec2;
 
 	/// 2 components vector of medium double-precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tvec2<double, mediump>	mediump_dvec2;
+	typedef vec<2, double, mediump>	mediump_dvec2;
 
 	/// 2 components vector of low double-precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tvec2<double, lowp>		lowp_dvec2;
+	typedef vec<2, double, lowp>		lowp_dvec2;
 
 	/// 2 components vector of high precision signed integer numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tvec2<int, highp>		highp_ivec2;
+	typedef vec<2, int, highp>		highp_ivec2;
 
 	/// 2 components vector of medium precision signed integer numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tvec2<int, mediump>		mediump_ivec2;
+	typedef vec<2, int, mediump>		mediump_ivec2;
 
 	/// 2 components vector of low precision signed integer numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tvec2<int, lowp>		lowp_ivec2;
+	typedef vec<2, int, lowp>		lowp_ivec2;
 
 	/// 2 components vector of high precision unsigned integer numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tvec2<uint, highp>		highp_uvec2;
+	typedef vec<2, uint, highp>		highp_uvec2;
 
 	/// 2 components vector of medium precision unsigned integer numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tvec2<uint, mediump>	mediump_uvec2;
+	typedef vec<2, uint, mediump>	mediump_uvec2;
 
 	/// 2 components vector of low precision unsigned integer numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tvec2<uint, lowp>		lowp_uvec2;
+	typedef vec<2, uint, lowp>		lowp_uvec2;
 
 	/// 2 components vector of high precision bool numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tvec2<bool, highp>		highp_bvec2;
+	typedef vec<2, bool, highp>		highp_bvec2;
 
 	/// 2 components vector of medium precision bool numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tvec2<bool, mediump>	mediump_bvec2;
+	typedef vec<2, bool, mediump>	mediump_bvec2;
 
 	/// 2 components vector of low precision bool numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tvec2<bool, lowp>		lowp_bvec2;
+	typedef vec<2, bool, lowp>		lowp_bvec2;
 
 	/// @}
 
@@ -240,102 +235,102 @@ namespace detail
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tvec3<float, highp>		highp_vec3;
+	typedef vec<3, float, highp>		highp_vec3;
 
 	/// 3 components vector of medium single-precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tvec3<float, mediump>	mediump_vec3;
+	typedef vec<3, float, mediump>	mediump_vec3;
 
 	/// 3 components vector of low single-precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tvec3<float, lowp>		lowp_vec3;
+	typedef vec<3, float, lowp>		lowp_vec3;
 
 	/// 3 components vector of high double-precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tvec3<double, highp>	highp_dvec3;
+	typedef vec<3, double, highp>	highp_dvec3;
 
 	/// 3 components vector of medium double-precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tvec3<double, mediump>	mediump_dvec3;
+	typedef vec<3, double, mediump>	mediump_dvec3;
 
 	/// 3 components vector of low double-precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tvec3<double, lowp>		lowp_dvec3;
+	typedef vec<3, double, lowp>		lowp_dvec3;
 
 	/// 3 components vector of high precision signed integer numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tvec3<int, highp>		highp_ivec3;
+	typedef vec<3, int, highp>		highp_ivec3;
 
 	/// 3 components vector of medium precision signed integer numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tvec3<int, mediump>		mediump_ivec3;
+	typedef vec<3, int, mediump>		mediump_ivec3;
 
 	/// 3 components vector of low precision signed integer numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tvec3<int, lowp>		lowp_ivec3;
+	typedef vec<3, int, lowp>		lowp_ivec3;
 
 	/// 3 components vector of high precision unsigned integer numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tvec3<uint, highp>		highp_uvec3;
+	typedef vec<3, uint, highp>		highp_uvec3;
 
 	/// 3 components vector of medium precision unsigned integer numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tvec3<uint, mediump>	mediump_uvec3;
+	typedef vec<3, uint, mediump>	mediump_uvec3;
 
 	/// 3 components vector of low precision unsigned integer numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tvec3<uint, lowp>		lowp_uvec3;
+	typedef vec<3, uint, lowp>		lowp_uvec3;
 
 	/// 3 components vector of high precision bool numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tvec3<bool, highp>		highp_bvec3;
+	typedef vec<3, bool, highp>		highp_bvec3;
 
 	/// 3 components vector of medium precision bool numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tvec3<bool, mediump>	mediump_bvec3;
+	typedef vec<3, bool, mediump>	mediump_bvec3;
 
 	/// 3 components vector of low precision bool numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tvec3<bool, lowp>		lowp_bvec3;
+	typedef vec<3, bool, lowp>		lowp_bvec3;
 
 	/// @}
 
@@ -346,91 +341,91 @@ namespace detail
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tvec4<float, highp>		highp_vec4;
+	typedef vec<4, float, highp>		highp_vec4;
 
 	/// 4 components vector of medium single-precision floating-point numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tvec4<float, mediump>	mediump_vec4;
+	typedef vec<4, float, mediump>	mediump_vec4;
 
 	/// 4 components vector of low single-precision floating-point numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tvec4<float, lowp>		lowp_vec4;
+	typedef vec<4, float, lowp>		lowp_vec4;
 
 	/// 4 components vector of high double-precision floating-point numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tvec4<double, highp>	highp_dvec4;
+	typedef vec<4, double, highp>	highp_dvec4;
 
 	/// 4 components vector of medium double-precision floating-point numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tvec4<double, mediump>	mediump_dvec4;
+	typedef vec<4, double, mediump>	mediump_dvec4;
 
 	/// 4 components vector of low double-precision floating-point numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tvec4<double, lowp>		lowp_dvec4;
+	typedef vec<4, double, lowp>		lowp_dvec4;
 
 	/// 4 components vector of high precision signed integer numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tvec4<int, highp>		highp_ivec4;
+	typedef vec<4, int, highp>		highp_ivec4;
 
 	/// 4 components vector of medium precision signed integer numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tvec4<int, mediump>		mediump_ivec4;
+	typedef vec<4, int, mediump>		mediump_ivec4;
 
 	/// 4 components vector of low precision signed integer numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tvec4<int, lowp>		lowp_ivec4;
+	typedef vec<4, int, lowp>		lowp_ivec4;
 
 	/// 4 components vector of high precision unsigned integer numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tvec4<uint, highp>		highp_uvec4;
+	typedef vec<4, uint, highp>		highp_uvec4;
 
 	/// 4 components vector of medium precision unsigned integer numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tvec4<uint, mediump>	mediump_uvec4;
+	typedef vec<4, uint, mediump>	mediump_uvec4;
 
 	/// 4 components vector of low precision unsigned integer numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tvec4<uint, lowp>		lowp_uvec4;
+	typedef vec<4, uint, lowp>		lowp_uvec4;
 
 	/// 4 components vector of high precision bool numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tvec4<bool, highp>		highp_bvec4;
+	typedef vec<4, bool, highp>		highp_bvec4;
 
 	/// 4 components vector of medium precision bool numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tvec4<bool, mediump>	mediump_bvec4;
+	typedef vec<4, bool, mediump>	mediump_bvec4;
 
 	/// 4 components vector of low precision bool numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tvec4<bool, lowp>		lowp_bvec4;
+	typedef vec<4, bool, lowp>		lowp_bvec4;
 
 	/// @}
 
diff --git a/glm/detail/type_vec1.hpp b/glm/detail/type_vec1.hpp
index 0d54ae00..b80aacf1 100644
--- a/glm/detail/type_vec1.hpp
+++ b/glm/detail/type_vec1.hpp
@@ -16,14 +16,14 @@
 
 namespace glm
 {
-	template <typename T, precision P = defaultp>
-	struct tvec1
+	template<typename T, precision P>
+	struct vec<1, T, P>
 	{
 		// -- Implementation detail --
 
 		typedef T value_type;
-		typedef tvec1<T, P> type;
-		typedef tvec1<bool, P> bool_type;
+		typedef vec type;
+		typedef vec<1, bool, P> bool_type;
 
 		// -- Data --
 
@@ -82,37 +82,37 @@ namespace glm
 
 		// -- Implicit basic constructors --
 
-		GLM_FUNC_DECL GLM_CONSTEXPR tvec1() GLM_DEFAULT_CTOR;
-		GLM_FUNC_DECL GLM_CONSTEXPR tvec1(tvec1<T, P> const & v) GLM_DEFAULT;
-		template <precision Q>
-		GLM_FUNC_DECL GLM_CONSTEXPR tvec1(tvec1<T, Q> const & v);
+		GLM_FUNC_DECL GLM_CONSTEXPR vec() GLM_DEFAULT_CTOR;
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec const & v) GLM_DEFAULT;
+		template<precision Q>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, T, Q> const & v);
 
 		// -- Explicit basic constructors --
 
-		GLM_FUNC_DECL GLM_CONSTEXPR_CTOR explicit tvec1(ctor);
-		GLM_FUNC_DECL GLM_CONSTEXPR explicit tvec1(T scalar);
+		GLM_FUNC_DECL GLM_CONSTEXPR_CTOR explicit vec(ctor);
+		GLM_FUNC_DECL GLM_CONSTEXPR explicit vec(T scalar);
 
 		// -- Conversion vector constructors --
 
 		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename U, precision Q>
-		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tvec1(tvec2<U, Q> const & v);
+		template<typename U, precision Q>
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT vec(vec<2, U, Q> const & v);
 		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename U, precision Q>
-		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tvec1(tvec3<U, Q> const & v);
+		template<typename U, precision Q>
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT vec(vec<3, U, Q> const & v);
 		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename U, precision Q>
-		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tvec1(tvec4<U, Q> const & v);
+		template<typename U, precision Q>
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT vec(vec<4, U, Q> const & v);
 
 		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename U, precision Q>
-		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tvec1(tvec1<U, Q> const & v);
+		template<typename U, precision Q>
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT vec(vec<1, U, Q> const & v);
 
 		// -- Swizzle constructors --
 /*
 #		if(GLM_HAS_UNRESTRICTED_UNIONS && (GLM_SWIZZLE == GLM_SWIZZLE_ENABLED))
-			template <int E0>
-			GLM_FUNC_DECL tvec1(detail::_swizzle<1, T, P, tvec1, E0, -1,-2,-3> const & that)
+			template<int E0>
+			GLM_FUNC_DECL tvec(detail::_swizzle<1, T, P, tvec1, E0, -1,-2,-3> const & that)
 			{
 				*this = that();
 			}
@@ -120,178 +120,178 @@ namespace glm
 */
 		// -- Unary arithmetic operators --
 
-		GLM_FUNC_DECL tvec1<T, P> & operator=(tvec1<T, P> const & v) GLM_DEFAULT;
+		GLM_FUNC_DECL vec & operator=(vec const & v) GLM_DEFAULT;
 
-		template <typename U>
-		GLM_FUNC_DECL tvec1<T, P> & operator=(tvec1<U, P> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec1<T, P> & operator+=(U scalar);
-		template <typename U>
-		GLM_FUNC_DECL tvec1<T, P> & operator+=(tvec1<U, P> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec1<T, P> & operator-=(U scalar);
-		template <typename U>
-		GLM_FUNC_DECL tvec1<T, P> & operator-=(tvec1<U, P> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec1<T, P> & operator*=(U scalar);
-		template <typename U>
-		GLM_FUNC_DECL tvec1<T, P> & operator*=(tvec1<U, P> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec1<T, P> & operator/=(U scalar);
-		template <typename U>
-		GLM_FUNC_DECL tvec1<T, P> & operator/=(tvec1<U, P> const & v);
+		template<typename U>
+		GLM_FUNC_DECL vec & operator=(vec<1, U, P> const & v);
+		template<typename U>
+		GLM_FUNC_DECL vec & operator+=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL vec & operator+=(vec<1, U, P> const & v);
+		template<typename U>
+		GLM_FUNC_DECL vec & operator-=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL vec & operator-=(vec<1, U, P> const & v);
+		template<typename U>
+		GLM_FUNC_DECL vec & operator*=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL vec & operator*=(vec<1, U, P> const & v);
+		template<typename U>
+		GLM_FUNC_DECL vec & operator/=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL vec & operator/=(vec<1, U, P> const & v);
 
 		// -- Increment and decrement operators --
 
-		GLM_FUNC_DECL tvec1<T, P> & operator++();
-		GLM_FUNC_DECL tvec1<T, P> & operator--();
-		GLM_FUNC_DECL tvec1<T, P> operator++(int);
-		GLM_FUNC_DECL tvec1<T, P> operator--(int);
+		GLM_FUNC_DECL vec & operator++();
+		GLM_FUNC_DECL vec & operator--();
+		GLM_FUNC_DECL vec operator++(int);
+		GLM_FUNC_DECL vec operator--(int);
 
 		// -- Unary bit operators --
 
-		template <typename U>
-		GLM_FUNC_DECL tvec1<T, P> & operator%=(U scalar);
-		template <typename U>
-		GLM_FUNC_DECL tvec1<T, P> & operator%=(tvec1<U, P> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec1<T, P> & operator&=(U scalar);
-		template <typename U>
-		GLM_FUNC_DECL tvec1<T, P> & operator&=(tvec1<U, P> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec1<T, P> & operator|=(U scalar);
-		template <typename U>
-		GLM_FUNC_DECL tvec1<T, P> & operator|=(tvec1<U, P> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec1<T, P> & operator^=(U scalar);
-		template <typename U>
-		GLM_FUNC_DECL tvec1<T, P> & operator^=(tvec1<U, P> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec1<T, P> & operator<<=(U scalar);
-		template <typename U>
-		GLM_FUNC_DECL tvec1<T, P> & operator<<=(tvec1<U, P> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec1<T, P> & operator>>=(U scalar);
-		template <typename U>
-		GLM_FUNC_DECL tvec1<T, P> & operator>>=(tvec1<U, P> const & v);
+		template<typename U>
+		GLM_FUNC_DECL vec & operator%=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL vec & operator%=(vec<1, U, P> const & v);
+		template<typename U>
+		GLM_FUNC_DECL vec & operator&=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL vec & operator&=(vec<1, U, P> const & v);
+		template<typename U>
+		GLM_FUNC_DECL vec & operator|=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL vec & operator|=(vec<1, U, P> const & v);
+		template<typename U>
+		GLM_FUNC_DECL vec & operator^=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL vec & operator^=(vec<1, U, P> const & v);
+		template<typename U>
+		GLM_FUNC_DECL vec & operator<<=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL vec & operator<<=(vec<1, U, P> const & v);
+		template<typename U>
+		GLM_FUNC_DECL vec & operator>>=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL vec & operator>>=(vec<1, U, P> const & v);
 	};
 
 	// -- Unary operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec1<T, P> operator+(tvec1<T, P> const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<1, T, P> operator+(vec<1, T, P> const & v);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec1<T, P> operator-(tvec1<T, P> const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<1, T, P> operator-(vec<1, T, P> const & v);
 
 	// -- Binary operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec1<T, P> operator+(tvec1<T, P> const & v, T scalar);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<1, T, P> operator+(vec<1, T, P> const & v, T scalar);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec1<T, P> operator+(T scalar, tvec1<T, P> const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<1, T, P> operator+(T scalar, vec<1, T, P> const & v);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec1<T, P> operator+(tvec1<T, P> const & v1, tvec1<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<1, T, P> operator+(vec<1, T, P> const & v1, vec<1, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec1<T, P> operator-(tvec1<T, P> const & v, T scalar);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<1, T, P> operator-(vec<1, T, P> const & v, T scalar);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec1<T, P> operator-(T scalar, tvec1<T, P> const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<1, T, P> operator-(T scalar, vec<1, T, P> const & v);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec1<T, P> operator-	(tvec1<T, P> const & v1, tvec1<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<1, T, P> operator-	(vec<1, T, P> const & v1, vec<1, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec1<T, P> operator*(tvec1<T, P> const & v, T scalar);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<1, T, P> operator*(vec<1, T, P> const & v, T scalar);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec1<T, P> operator*(T scalar, tvec1<T, P> const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<1, T, P> operator*(T scalar, vec<1, T, P> const & v);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec1<T, P> operator*(tvec1<T, P> const & v1, tvec1<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<1, T, P> operator*(vec<1, T, P> const & v1, vec<1, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec1<T, P> operator/(tvec1<T, P> const & v, T scalar);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<1, T, P> operator/(vec<1, T, P> const & v, T scalar);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec1<T, P> operator/(T scalar, tvec1<T, P> const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<1, T, P> operator/(T scalar, vec<1, T, P> const & v);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec1<T, P> operator/(tvec1<T, P> const & v1, tvec1<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<1, T, P> operator/(vec<1, T, P> const & v1, vec<1, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec1<T, P> operator%(tvec1<T, P> const & v, T scalar);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<1, T, P> operator%(vec<1, T, P> const & v, T scalar);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec1<T, P> operator%(T scalar, tvec1<T, P> const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<1, T, P> operator%(T scalar, vec<1, T, P> const & v);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec1<T, P> operator%(tvec1<T, P> const & v1, tvec1<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<1, T, P> operator%(vec<1, T, P> const & v1, vec<1, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec1<T, P> operator&(tvec1<T, P> const & v, T scalar);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<1, T, P> operator&(vec<1, T, P> const & v, T scalar);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec1<T, P> operator&(T scalar, tvec1<T, P> const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<1, T, P> operator&(T scalar, vec<1, T, P> const & v);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec1<T, P> operator&(tvec1<T, P> const & v1, tvec1<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<1, T, P> operator&(vec<1, T, P> const & v1, vec<1, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec1<T, P> operator|(tvec1<T, P> const & v, T scalar);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<1, T, P> operator|(vec<1, T, P> const & v, T scalar);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec1<T, P> operator|(T scalar, tvec1<T, P> const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<1, T, P> operator|(T scalar, vec<1, T, P> const & v);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec1<T, P> operator|(tvec1<T, P> const & v1, tvec1<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<1, T, P> operator|(vec<1, T, P> const & v1, vec<1, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec1<T, P> operator^(tvec1<T, P> const & v, T scalar);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<1, T, P> operator^(vec<1, T, P> const & v, T scalar);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec1<T, P> operator^(T scalar, tvec1<T, P> const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<1, T, P> operator^(T scalar, vec<1, T, P> const & v);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec1<T, P> operator^(tvec1<T, P> const & v1, tvec1<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<1, T, P> operator^(vec<1, T, P> const & v1, vec<1, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec1<T, P> operator<<(tvec1<T, P> const & v, T scalar);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<1, T, P> operator<<(vec<1, T, P> const & v, T scalar);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec1<T, P> operator<<(T scalar, tvec1<T, P> const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<1, T, P> operator<<(T scalar, vec<1, T, P> const & v);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec1<T, P> operator<<(tvec1<T, P> const & v1, tvec1<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<1, T, P> operator<<(vec<1, T, P> const & v1, vec<1, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec1<T, P> operator>>(tvec1<T, P> const & v, T scalar);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<1, T, P> operator>>(vec<1, T, P> const & v, T scalar);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec1<T, P> operator>>(T scalar, tvec1<T, P> const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<1, T, P> operator>>(T scalar, vec<1, T, P> const & v);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec1<T, P> operator>>(tvec1<T, P> const & v1, tvec1<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<1, T, P> operator>>(vec<1, T, P> const & v1, vec<1, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec1<T, P> operator~(tvec1<T, P> const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<1, T, P> operator~(vec<1, T, P> const & v);
 
 	// -- Boolean operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL bool operator==(tvec1<T, P> const & v1, tvec1<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL bool operator==(vec<1, T, P> const & v1, vec<1, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL bool operator!=(tvec1<T, P> const & v1, tvec1<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL bool operator!=(vec<1, T, P> const & v1, vec<1, T, P> const & v2);
 
-	template <precision P>
-	GLM_FUNC_DECL tvec1<bool, P> operator&&(tvec1<bool, P> const & v1, tvec1<bool, P> const & v2);
+	template<precision P>
+	GLM_FUNC_DECL vec<1, bool, P> operator&&(vec<1, bool, P> const & v1, vec<1, bool, P> const & v2);
 
-	template <precision P>
-	GLM_FUNC_DECL tvec1<bool, P> operator||(tvec1<bool, P> const & v1, tvec1<bool, P> const & v2);
+	template<precision P>
+	GLM_FUNC_DECL vec<1, bool, P> operator||(vec<1, bool, P> const & v1, vec<1, bool, P> const & v2);
 }//namespace glm
 
 #ifndef GLM_EXTERNAL_TEMPLATE
diff --git a/glm/detail/type_vec1.inl b/glm/detail/type_vec1.inl
index 3c872958..26a45856 100644
--- a/glm/detail/type_vec1.inl
+++ b/glm/detail/type_vec1.inl
@@ -6,8 +6,8 @@ namespace glm
 	// -- Implicit basic constructors --
 
 #	if !GLM_HAS_DEFAULTED_FUNCTIONS || !defined(GLM_FORCE_NO_CTOR_INIT)
-		template <typename T, precision P>
-		GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec1<T, P>::tvec1()
+		template<typename T, precision P>
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, P>::vec()
 #			ifndef GLM_FORCE_NO_CTOR_INIT
 				: x(0)
 #			endif
@@ -15,66 +15,66 @@ namespace glm
 #	endif//!GLM_HAS_DEFAULTED_FUNCTIONS
 
 #	if !GLM_HAS_DEFAULTED_FUNCTIONS
-		template <typename T, precision P>
-		GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec1<T, P>::tvec1(tvec1<T, P> const & v)
+		template<typename T, precision P>
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, P>::vec(vec<1, T, P> const & v)
 			: x(v.x)
 		{}
 #	endif//!GLM_HAS_DEFAULTED_FUNCTIONS
 
-	template <typename T, precision P>
-	template <precision Q>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec1<T, P>::tvec1(tvec1<T, Q> const & v)
+	template<typename T, precision P>
+	template<precision Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, P>::vec(vec<1, T, Q> const & v)
 		: x(v.x)
 	{}
 
 	// -- Explicit basic constructors --
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR tvec1<T, P>::tvec1(ctor)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<1, T, P>::vec(ctor)
 	{}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec1<T, P>::tvec1(T scalar)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, P>::vec(T scalar)
 		: x(scalar)
 	{}
 
 	// -- Conversion vector constructors --
 
-	template <typename T, precision P>
-	template <typename U, precision Q>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec1<T, P>::tvec1(tvec1<U, Q> const & v)
+	template<typename T, precision P>
+	template<typename U, precision Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, P>::vec(vec<1, U, Q> const & v)
 		: x(static_cast<T>(v.x))
 	{}
 
-	template <typename T, precision P>
-	template <typename U, precision Q>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec1<T, P>::tvec1(tvec2<U, Q> const & v)
+	template<typename T, precision P>
+	template<typename U, precision Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, P>::vec(vec<2, U, Q> const & v)
 		: x(static_cast<T>(v.x))
 	{}
 
-	template <typename T, precision P>
-	template <typename U, precision Q>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec1<T, P>::tvec1(tvec3<U, Q> const & v)
+	template<typename T, precision P>
+	template<typename U, precision Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, P>::vec(vec<3, U, Q> const & v)
 		: x(static_cast<T>(v.x))
 	{}
 
-	template <typename T, precision P>
-	template <typename U, precision Q>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec1<T, P>::tvec1(tvec4<U, Q> const & v)
+	template<typename T, precision P>
+	template<typename U, precision Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, P>::vec(vec<4, U, Q> const & v)
 		: x(static_cast<T>(v.x))
 	{}
 
 	// -- Component accesses --
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER T & tvec1<T, P>::operator[](typename tvec1<T, P>::length_type i)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER T & vec<1, T, P>::operator[](typename vec<1, T, P>::length_type i)
 	{
 		assert(i >= 0 && i < this->length());
 		return (&x)[i];
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER T const & tvec1<T, P>::operator[](typename tvec1<T, P>::length_type i) const
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER T const & vec<1, T, P>::operator[](typename vec<1, T, P>::length_type i) const
 	{
 		assert(i >= 0 && i < this->length());
 		return (&x)[i];
@@ -83,81 +83,81 @@ namespace glm
 	// -- Unary arithmetic operators --
 
 #	if !GLM_HAS_DEFAULTED_FUNCTIONS
-		template <typename T, precision P>
-		GLM_FUNC_QUALIFIER tvec1<T, P> & tvec1<T, P>::operator=(tvec1<T, P> const & v)
+		template<typename T, precision P>
+		GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator=(vec<1, T, P> const & v)
 		{
 			this->x = v.x;
 			return *this;
 		}
 #	endif//!GLM_HAS_DEFAULTED_FUNCTIONS
 
-	template <typename T, precision P>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec1<T, P> & tvec1<T, P>::operator=(tvec1<U, P> const & v)
+	template<typename T, precision P>
+	template<typename U> 
+	GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator=(vec<1, U, P> const & v)
 	{
 		this->x = static_cast<T>(v.x);
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec1<T, P> & tvec1<T, P>::operator+=(U scalar)
+	template<typename T, precision P>
+	template<typename U> 
+	GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator+=(U scalar)
 	{
 		this->x += static_cast<T>(scalar);
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec1<T, P> & tvec1<T, P>::operator+=(tvec1<U, P> const & v)
+	template<typename T, precision P>
+	template<typename U> 
+	GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator+=(vec<1, U, P> const & v)
 	{
 		this->x += static_cast<T>(v.x);
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec1<T, P> & tvec1<T, P>::operator-=(U scalar)
+	template<typename T, precision P>
+	template<typename U> 
+	GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator-=(U scalar)
 	{
 		this->x -= static_cast<T>(scalar);
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec1<T, P> & tvec1<T, P>::operator-=(tvec1<U, P> const & v)
+	template<typename T, precision P>
+	template<typename U> 
+	GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator-=(vec<1, U, P> const & v)
 	{
 		this->x -= static_cast<T>(v.x);
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec1<T, P> & tvec1<T, P>::operator*=(U scalar)
+	template<typename T, precision P>
+	template<typename U> 
+	GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator*=(U scalar)
 	{
 		this->x *= static_cast<T>(scalar);
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec1<T, P> & tvec1<T, P>::operator*=(tvec1<U, P> const & v)
+	template<typename T, precision P>
+	template<typename U> 
+	GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator*=(vec<1, U, P> const & v)
 	{
 		this->x *= static_cast<T>(v.x);
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec1<T, P> & tvec1<T, P>::operator/=(U scalar)
+	template<typename T, precision P>
+	template<typename U> 
+	GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator/=(U scalar)
 	{
 		this->x /= static_cast<T>(scalar);
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec1<T, P> & tvec1<T, P>::operator/=(tvec1<U, P> const & v)
+	template<typename T, precision P>
+	template<typename U> 
+	GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator/=(vec<1, U, P> const & v)
 	{
 		this->x /= static_cast<T>(v.x);
 		return *this;
@@ -165,129 +165,129 @@ namespace glm
 
 	// -- Increment and decrement operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec1<T, P> & tvec1<T, P>::operator++()
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator++()
 	{
 		++this->x;
 		return *this;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec1<T, P> & tvec1<T, P>::operator--()
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator--()
 	{
 		--this->x;
 		return *this;
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tvec1<T, P> tvec1<T, P>::operator++(int)
+	template<typename T, precision P> 
+	GLM_FUNC_QUALIFIER vec<1, T, P> vec<1, T, P>::operator++(int)
 	{
-		tvec1<T, P> Result(*this);
+		vec<1, T, P> Result(*this);
 		++*this;
 		return Result;
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tvec1<T, P> tvec1<T, P>::operator--(int)
+	template<typename T, precision P> 
+	GLM_FUNC_QUALIFIER vec<1, T, P> vec<1, T, P>::operator--(int)
 	{
-		tvec1<T, P> Result(*this);
+		vec<1, T, P> Result(*this);
 		--*this;
 		return Result;
 	}
 
 	// -- Unary bit operators --
 
-	template <typename T, precision P>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec1<T, P> & tvec1<T, P>::operator%=(U scalar)
+	template<typename T, precision P>
+	template<typename U> 
+	GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator%=(U scalar)
 	{
 		this->x %= static_cast<T>(scalar);
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec1<T, P> & tvec1<T, P>::operator%=(tvec1<U, P> const & v)
+	template<typename T, precision P>
+	template<typename U> 
+	GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator%=(vec<1, U, P> const & v)
 	{
 		this->x %= static_cast<T>(v.x);
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec1<T, P> & tvec1<T, P>::operator&=(U scalar)
+	template<typename T, precision P>
+	template<typename U> 
+	GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator&=(U scalar)
 	{
 		this->x &= static_cast<T>(scalar);
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec1<T, P> & tvec1<T, P>::operator&=(tvec1<U, P> const & v)
+	template<typename T, precision P>
+	template<typename U> 
+	GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator&=(vec<1, U, P> const & v)
 	{
 		this->x &= static_cast<T>(v.x);
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec1<T, P> & tvec1<T, P>::operator|=(U scalar)
+	template<typename T, precision P>
+	template<typename U> 
+	GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator|=(U scalar)
 	{
 		this->x |= static_cast<T>(scalar);
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec1<T, P> & tvec1<T, P>::operator|=(tvec1<U, P> const & v)
+	template<typename T, precision P>
+	template<typename U> 
+	GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator|=(vec<1, U, P> const & v)
 	{
 		this->x |= U(v.x);
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec1<T, P> & tvec1<T, P>::operator^=(U scalar)
+	template<typename T, precision P>
+	template<typename U> 
+	GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator^=(U scalar)
 	{
 		this->x ^= static_cast<T>(scalar);
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec1<T, P> & tvec1<T, P>::operator^=(tvec1<U, P> const & v)
+	template<typename T, precision P>
+	template<typename U> 
+	GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator^=(vec<1, U, P> const & v)
 	{
 		this->x ^= static_cast<T>(v.x);
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec1<T, P> & tvec1<T, P>::operator<<=(U scalar)
+	template<typename T, precision P>
+	template<typename U> 
+	GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator<<=(U scalar)
 	{
 		this->x <<= static_cast<T>(scalar);
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec1<T, P> & tvec1<T, P>::operator<<=(tvec1<U, P> const & v)
+	template<typename T, precision P>
+	template<typename U> 
+	GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator<<=(vec<1, U, P> const & v)
 	{
 		this->x <<= static_cast<T>(v.x);
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec1<T, P> & tvec1<T, P>::operator>>=(U scalar)
+	template<typename T, precision P>
+	template<typename U> 
+	GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator>>=(U scalar)
 	{
 		this->x >>= static_cast<T>(scalar);
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec1<T, P> & tvec1<T, P>::operator>>=(tvec1<U, P> const & v)
+	template<typename T, precision P>
+	template<typename U> 
+	GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator>>=(vec<1, U, P> const & v)
 	{
 		this->x >>= static_cast<T>(v.x);
 		return *this;
@@ -295,264 +295,264 @@ namespace glm
 
 	// -- Unary constant operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec1<T, P> operator+(tvec1<T, P> const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<1, T, P> operator+(vec<1, T, P> const & v)
 	{
 		return v;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec1<T, P> operator-(tvec1<T, P> const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<1, T, P> operator-(vec<1, T, P> const & v)
 	{
-		return tvec1<T, P>(
+		return vec<1, T, P>(
 			-v.x);
 	}
 
 	// -- Binary arithmetic operators --
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tvec1<T, P> operator+(tvec1<T, P> const & v, T scalar)
+	template<typename T, precision P> 
+	GLM_FUNC_QUALIFIER vec<1, T, P> operator+(vec<1, T, P> const & v, T scalar)
 	{
-		return tvec1<T, P>(
+		return vec<1, T, P>(
 			v.x + scalar);
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tvec1<T, P> operator+(T scalar, tvec1<T, P> const & v)
+	template<typename T, precision P> 
+	GLM_FUNC_QUALIFIER vec<1, T, P> operator+(T scalar, vec<1, T, P> const & v)
 	{
-		return tvec1<T, P>(
+		return vec<1, T, P>(
 			scalar + v.x);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec1<T, P> operator+(tvec1<T, P> const & v1, tvec1<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<1, T, P> operator+(vec<1, T, P> const & v1, vec<1, T, P> const & v2)
 	{
-		return tvec1<T, P>(
+		return vec<1, T, P>(
 			v1.x + v2.x);
 	}
 
 	//operator-
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tvec1<T, P> operator-(tvec1<T, P> const & v, T scalar)
+	template<typename T, precision P> 
+	GLM_FUNC_QUALIFIER vec<1, T, P> operator-(vec<1, T, P> const & v, T scalar)
 	{
-		return tvec1<T, P>(
+		return vec<1, T, P>(
 			v.x - scalar);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec1<T, P> operator-(T scalar, tvec1<T, P> const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<1, T, P> operator-(T scalar, vec<1, T, P> const & v)
 	{
-		return tvec1<T, P>(
+		return vec<1, T, P>(
 			scalar - v.x);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec1<T, P> operator-(tvec1<T, P> const & v1, tvec1<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<1, T, P> operator-(vec<1, T, P> const & v1, vec<1, T, P> const & v2)
 	{
-		return tvec1<T, P>(
+		return vec<1, T, P>(
 			v1.x - v2.x);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec1<T, P> operator*(tvec1<T, P> const & v, T scalar)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<1, T, P> operator*(vec<1, T, P> const & v, T scalar)
 	{
-		return tvec1<T, P>(
+		return vec<1, T, P>(
 			v.x * scalar);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec1<T, P> operator*(T scalar, tvec1<T, P> const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<1, T, P> operator*(T scalar, vec<1, T, P> const & v)
 	{
-		return tvec1<T, P>(
+		return vec<1, T, P>(
 			scalar * v.x);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec1<T, P> operator*(tvec1<T, P> const & v1, tvec1<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<1, T, P> operator*(vec<1, T, P> const & v1, vec<1, T, P> const & v2)
 	{
-		return tvec1<T, P>(
+		return vec<1, T, P>(
 			v1.x * v2.x);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec1<T, P> operator/(tvec1<T, P> const & v, T scalar)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<1, T, P> operator/(vec<1, T, P> const & v, T scalar)
 	{
-		return tvec1<T, P>(
+		return vec<1, T, P>(
 			v.x / scalar);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec1<T, P> operator/(T scalar, tvec1<T, P> const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<1, T, P> operator/(T scalar, vec<1, T, P> const & v)
 	{
-		return tvec1<T, P>(
+		return vec<1, T, P>(
 			scalar / v.x);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec1<T, P> operator/(tvec1<T, P> const & v1, tvec1<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<1, T, P> operator/(vec<1, T, P> const & v1, vec<1, T, P> const & v2)
 	{
-		return tvec1<T, P>(
+		return vec<1, T, P>(
 			v1.x / v2.x);
 	}
 
 	// -- Binary bit operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec1<T, P> operator%(tvec1<T, P> const & v, T scalar)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<1, T, P> operator%(vec<1, T, P> const & v, T scalar)
 	{
-		return tvec1<T, P>(
+		return vec<1, T, P>(
 			v.x % scalar);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec1<T, P> operator%(T scalar, tvec1<T, P> const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<1, T, P> operator%(T scalar, vec<1, T, P> const & v)
 	{
-		return tvec1<T, P>(
+		return vec<1, T, P>(
 			scalar % v.x);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec1<T, P> operator%(tvec1<T, P> const & v1, tvec1<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<1, T, P> operator%(vec<1, T, P> const & v1, vec<1, T, P> const & v2)
 	{
-		return tvec1<T, P>(
+		return vec<1, T, P>(
 			v1.x % v2.x);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec1<T, P> operator&(tvec1<T, P> const & v, T scalar)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<1, T, P> operator&(vec<1, T, P> const & v, T scalar)
 	{
-		return tvec1<T, P>(
+		return vec<1, T, P>(
 			v.x & scalar);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec1<T, P> operator&(T scalar, tvec1<T, P> const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<1, T, P> operator&(T scalar, vec<1, T, P> const & v)
 	{
-		return tvec1<T, P>(
+		return vec<1, T, P>(
 			scalar & v.x);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec1<T, P> operator&(tvec1<T, P> const & v1, tvec1<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<1, T, P> operator&(vec<1, T, P> const & v1, vec<1, T, P> const & v2)
 	{
-		return tvec1<T, P>(
+		return vec<1, T, P>(
 			v1.x & v2.x);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec1<T, P> operator|(tvec1<T, P> const & v, T scalar)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<1, T, P> operator|(vec<1, T, P> const & v, T scalar)
 	{
-		return tvec1<T, P>(
+		return vec<1, T, P>(
 			v.x | scalar);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec1<T, P> operator|(T scalar, tvec1<T, P> const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<1, T, P> operator|(T scalar, vec<1, T, P> const & v)
 	{
-		return tvec1<T, P>(
+		return vec<1, T, P>(
 			scalar | v.x);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec1<T, P> operator|(tvec1<T, P> const & v1, tvec1<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<1, T, P> operator|(vec<1, T, P> const & v1, vec<1, T, P> const & v2)
 	{
-		return tvec1<T, P>(
+		return vec<1, T, P>(
 			v1.x | v2.x);
 	}
 		
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec1<T, P> operator^(tvec1<T, P> const & v, T scalar)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<1, T, P> operator^(vec<1, T, P> const & v, T scalar)
 	{
-		return tvec1<T, P>(
+		return vec<1, T, P>(
 			v.x ^ scalar);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec1<T, P> operator^(T scalar, tvec1<T, P> const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<1, T, P> operator^(T scalar, vec<1, T, P> const & v)
 	{
-		return tvec1<T, P>(
+		return vec<1, T, P>(
 			scalar ^ v.x);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec1<T, P> operator^(tvec1<T, P> const & v1, tvec1<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<1, T, P> operator^(vec<1, T, P> const & v1, vec<1, T, P> const & v2)
 	{
-		return tvec1<T, P>(
+		return vec<1, T, P>(
 			v1.x ^ v2.x);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec1<T, P> operator<<(tvec1<T, P> const & v, T scalar)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<1, T, P> operator<<(vec<1, T, P> const & v, T scalar)
 	{
-		return tvec1<T, P>(
+		return vec<1, T, P>(
 			v.x << scalar);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec1<T, P> operator<<(T scalar, tvec1<T, P> const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<1, T, P> operator<<(T scalar, vec<1, T, P> const & v)
 	{
-		return tvec1<T, P>(
+		return vec<1, T, P>(
 			scalar << v.x);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec1<T, P> operator<<(tvec1<T, P> const & v1, tvec1<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<1, T, P> operator<<(vec<1, T, P> const & v1, vec<1, T, P> const & v2)
 	{
-		return tvec1<T, P>(
+		return vec<1, T, P>(
 			v1.x << v2.x);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec1<T, P> operator>>(tvec1<T, P> const & v, T scalar)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<1, T, P> operator>>(vec<1, T, P> const & v, T scalar)
 	{
-		return tvec1<T, P>(
+		return vec<1, T, P>(
 			v.x >> scalar);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec1<T, P> operator>>(T scalar, tvec1<T, P> const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<1, T, P> operator>>(T scalar, vec<1, T, P> const & v)
 	{
-		return tvec1<T, P>(
+		return vec<1, T, P>(
 			scalar >> v.x);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec1<T, P> operator>>(tvec1<T, P> const & v1, tvec1<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<1, T, P> operator>>(vec<1, T, P> const & v1, vec<1, T, P> const & v2)
 	{
-		return tvec1<T, P>(
+		return vec<1, T, P>(
 			v1.x >> v2.x);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec1<T, P> operator~(tvec1<T, P> const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<1, T, P> operator~(vec<1, T, P> const & v)
 	{
-		return tvec1<T, P>(
+		return vec<1, T, P>(
 			~v.x);
 	}
 
 	// -- Boolean operators --
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER bool operator==(tvec1<T, P> const & v1, tvec1<T, P> const & v2)
+	template<typename T, precision P> 
+	GLM_FUNC_QUALIFIER bool operator==(vec<1, T, P> const & v1, vec<1, T, P> const & v2)
 	{
 		return (v1.x == v2.x);
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER bool operator!=(tvec1<T, P> const & v1, tvec1<T, P> const & v2)
+	template<typename T, precision P> 
+	GLM_FUNC_QUALIFIER bool operator!=(vec<1, T, P> const & v1, vec<1, T, P> const & v2)
 	{
 		return (v1.x != v2.x);
 	}
 
-	template <precision P>
-	GLM_FUNC_QUALIFIER tvec1<bool, P> operator&&(tvec1<bool, P> const & v1, tvec1<bool, P> const & v2)
+	template<precision P>
+	GLM_FUNC_QUALIFIER vec<1, bool, P> operator&&(vec<1, bool, P> const & v1, vec<1, bool, P> const & v2)
 	{
-		return tvec1<bool, P>(v1.x && v2.x);
+		return vec<1, bool, P>(v1.x && v2.x);
 	}
 
-	template <precision P>
-	GLM_FUNC_QUALIFIER tvec1<bool, P> operator||(tvec1<bool, P> const & v1, tvec1<bool, P> const & v2)
+	template<precision P>
+	GLM_FUNC_QUALIFIER vec<1, bool, P> operator||(vec<1, bool, P> const & v1, vec<1, bool, P> const & v2)
 	{
-		return tvec1<bool, P>(v1.x || v2.x);
+		return vec<1, bool, P>(v1.x || v2.x);
 	}
 }//namespace glm
diff --git a/glm/detail/type_vec2.hpp b/glm/detail/type_vec2.hpp
index d7f7c213..427ed850 100644
--- a/glm/detail/type_vec2.hpp
+++ b/glm/detail/type_vec2.hpp
@@ -15,14 +15,14 @@
 
 namespace glm
 {
-	template <typename T, precision P = defaultp>
-	struct tvec2
+	template<typename T, precision P>
+	struct vec<2, T, P>
 	{
 		// -- Implementation detail --
 
 		typedef T value_type;
-		typedef tvec2<T, P> type;
-		typedef tvec2<bool, P> bool_type;
+		typedef vec type;
+		typedef vec<2, bool, P> bool_type;
 
 		// -- Data --
 
@@ -44,15 +44,15 @@ namespace glm
 				struct{ T s, t; };
 
 #				if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED
-					_GLM_SWIZZLE2_2_MEMBERS(T, P, glm::tvec2, x, y)
-					_GLM_SWIZZLE2_2_MEMBERS(T, P, glm::tvec2, r, g)
-					_GLM_SWIZZLE2_2_MEMBERS(T, P, glm::tvec2, s, t)
-					_GLM_SWIZZLE2_3_MEMBERS(T, P, glm::tvec3, x, y)
-					_GLM_SWIZZLE2_3_MEMBERS(T, P, glm::tvec3, r, g)
-					_GLM_SWIZZLE2_3_MEMBERS(T, P, glm::tvec3, s, t)
-					_GLM_SWIZZLE2_4_MEMBERS(T, P, glm::tvec4, x, y)
-					_GLM_SWIZZLE2_4_MEMBERS(T, P, glm::tvec4, r, g)
-					_GLM_SWIZZLE2_4_MEMBERS(T, P, glm::tvec4, s, t)
+					_GLM_SWIZZLE2_2_MEMBERS(T, P, x, y)
+					_GLM_SWIZZLE2_2_MEMBERS(T, P, r, g)
+					_GLM_SWIZZLE2_2_MEMBERS(T, P, s, t)
+					_GLM_SWIZZLE2_3_MEMBERS(T, P, x, y)
+					_GLM_SWIZZLE2_3_MEMBERS(T, P, r, g)
+					_GLM_SWIZZLE2_3_MEMBERS(T, P, s, t)
+					_GLM_SWIZZLE2_4_MEMBERS(T, P, x, y)
+					_GLM_SWIZZLE2_4_MEMBERS(T, P, r, g)
+					_GLM_SWIZZLE2_4_MEMBERS(T, P, s, t)
 #				endif//GLM_SWIZZLE
 
 			};
@@ -68,7 +68,7 @@ namespace glm
 			union {T y, g, t;};
 
 #			if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED
-				GLM_SWIZZLE_GEN_VEC_FROM_VEC2(T, P, tvec2, tvec2, tvec3, tvec4)
+				GLM_SWIZZLE_GEN_VEC_FROM_VEC2(T, P)
 #			endif//GLM_SWIZZLE
 #		endif
 
@@ -83,42 +83,42 @@ namespace glm
 
 		// -- Implicit basic constructors --
 
-		GLM_FUNC_DECL GLM_CONSTEXPR tvec2() GLM_DEFAULT_CTOR;
-		GLM_FUNC_DECL GLM_CONSTEXPR tvec2(tvec2<T, P> const& v) GLM_DEFAULT;
-		template <precision Q>
-		GLM_FUNC_DECL GLM_CONSTEXPR tvec2(tvec2<T, Q> const& v);
+		GLM_FUNC_DECL GLM_CONSTEXPR vec() GLM_DEFAULT_CTOR;
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec const& v) GLM_DEFAULT;
+		template<precision Q>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<2, T, Q> const& v);
 
 		// -- Explicit basic constructors --
 
-		GLM_FUNC_DECL GLM_CONSTEXPR_CTOR explicit tvec2(ctor);
-		GLM_FUNC_DECL GLM_CONSTEXPR explicit tvec2(T scalar);
-		GLM_FUNC_DECL GLM_CONSTEXPR tvec2(T s1, T s2);
+		GLM_FUNC_DECL GLM_CONSTEXPR_CTOR explicit vec(ctor);
+		GLM_FUNC_DECL GLM_CONSTEXPR explicit vec(T scalar);
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(T s1, T s2);
 
 		// -- Conversion constructors --
 
-		/// Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename A, typename B>
-		GLM_FUNC_DECL GLM_CONSTEXPR tvec2(A x, B y);
-		template <typename A, typename B>
-		GLM_FUNC_DECL GLM_CONSTEXPR tvec2(tvec1<A, P> const & v1, tvec1<B, P> const & v2);
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template<typename A, typename B>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(A x, B y);
+		template<typename A, typename B>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, A, P> const & v1, vec<1, B, P> const & v2);
 
 		// -- Conversion vector constructors --
 
 		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename U, precision Q>
-		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tvec2(tvec3<U, Q> const & v);
+		template<typename U, precision Q>
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT vec(vec<3, U, Q> const & v);
 		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename U, precision Q>
-		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tvec2(tvec4<U, Q> const & v);
+		template<typename U, precision Q>
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT vec(vec<4, U, Q> const & v);
 
 		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename U, precision Q>
-		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tvec2(tvec2<U, Q> const & v);
+		template<typename U, precision Q>
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT vec(vec<2, U, Q> const & v);
 
 		// -- Swizzle constructors --
 #		if GLM_HAS_UNRESTRICTED_UNIONS && (GLM_SWIZZLE == GLM_SWIZZLE_ENABLED)
-			template <int E0, int E1>
-			GLM_FUNC_DECL tvec2(detail::_swizzle<2, T, P, glm::tvec2, E0, E1,-1,-2> const& that)
+			template<int E0, int E1>
+			GLM_FUNC_DECL vec(detail::_swizzle<2, T, P, E0, E1,-1,-2> const& that)
 			{
 				*this = that();
 			}
@@ -126,258 +126,258 @@ namespace glm
 
 		// -- Unary arithmetic operators --
 
-		GLM_FUNC_DECL tvec2<T, P>& operator=(tvec2<T, P> const & v) GLM_DEFAULT;
+		GLM_FUNC_DECL vec& operator=(vec const & v) GLM_DEFAULT;
 
-		template <typename U>
-		GLM_FUNC_DECL tvec2<T, P>& operator=(tvec2<U, P> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec2<T, P>& operator+=(U scalar);
-		template <typename U>
-		GLM_FUNC_DECL tvec2<T, P>& operator+=(tvec1<U, P> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec2<T, P>& operator+=(tvec2<U, P> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec2<T, P>& operator-=(U scalar);
-		template <typename U>
-		GLM_FUNC_DECL tvec2<T, P>& operator-=(tvec1<U, P> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec2<T, P>& operator-=(tvec2<U, P> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec2<T, P>& operator*=(U scalar);
-		template <typename U>
-		GLM_FUNC_DECL tvec2<T, P>& operator*=(tvec1<U, P> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec2<T, P>& operator*=(tvec2<U, P> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec2<T, P>& operator/=(U scalar);
-		template <typename U>
-		GLM_FUNC_DECL tvec2<T, P>& operator/=(tvec1<U, P> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec2<T, P>& operator/=(tvec2<U, P> const & v);
+		template<typename U>
+		GLM_FUNC_DECL vec& operator=(vec<2, U, P> const & v);
+		template<typename U>
+		GLM_FUNC_DECL vec& operator+=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL vec& operator+=(vec<1, U, P> const & v);
+		template<typename U>
+		GLM_FUNC_DECL vec& operator+=(vec<2, U, P> const & v);
+		template<typename U>
+		GLM_FUNC_DECL vec& operator-=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL vec& operator-=(vec<1, U, P> const & v);
+		template<typename U>
+		GLM_FUNC_DECL vec& operator-=(vec<2, U, P> const & v);
+		template<typename U>
+		GLM_FUNC_DECL vec& operator*=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL vec& operator*=(vec<1, U, P> const & v);
+		template<typename U>
+		GLM_FUNC_DECL vec& operator*=(vec<2, U, P> const & v);
+		template<typename U>
+		GLM_FUNC_DECL vec& operator/=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL vec& operator/=(vec<1, U, P> const & v);
+		template<typename U>
+		GLM_FUNC_DECL vec& operator/=(vec<2, U, P> const & v);
 
 		// -- Increment and decrement operators --
 
-		GLM_FUNC_DECL tvec2<T, P> & operator++();
-		GLM_FUNC_DECL tvec2<T, P> & operator--();
-		GLM_FUNC_DECL tvec2<T, P> operator++(int);
-		GLM_FUNC_DECL tvec2<T, P> operator--(int);
+		GLM_FUNC_DECL vec & operator++();
+		GLM_FUNC_DECL vec & operator--();
+		GLM_FUNC_DECL vec operator++(int);
+		GLM_FUNC_DECL vec operator--(int);
 
 		// -- Unary bit operators --
 
-		template <typename U> 
-		GLM_FUNC_DECL tvec2<T, P> & operator%=(U scalar);
-		template <typename U> 
-		GLM_FUNC_DECL tvec2<T, P> & operator%=(tvec1<U, P> const & v);
-		template <typename U> 
-		GLM_FUNC_DECL tvec2<T, P> & operator%=(tvec2<U, P> const & v);
-		template <typename U> 
-		GLM_FUNC_DECL tvec2<T, P> & operator&=(U scalar);
-		template <typename U> 
-		GLM_FUNC_DECL tvec2<T, P> & operator&=(tvec1<U, P> const & v);
-		template <typename U> 
-		GLM_FUNC_DECL tvec2<T, P> & operator&=(tvec2<U, P> const & v);
-		template <typename U> 
-		GLM_FUNC_DECL tvec2<T, P> & operator|=(U scalar);
-		template <typename U> 
-		GLM_FUNC_DECL tvec2<T, P> & operator|=(tvec1<U, P> const & v);
-		template <typename U> 
-		GLM_FUNC_DECL tvec2<T, P> & operator|=(tvec2<U, P> const & v);
-		template <typename U> 
-		GLM_FUNC_DECL tvec2<T, P> & operator^=(U scalar);
-		template <typename U> 
-		GLM_FUNC_DECL tvec2<T, P> & operator^=(tvec1<U, P> const & v);
-		template <typename U> 
-		GLM_FUNC_DECL tvec2<T, P> & operator^=(tvec2<U, P> const & v);
-		template <typename U> 
-		GLM_FUNC_DECL tvec2<T, P> & operator<<=(U scalar);
-		template <typename U> 
-		GLM_FUNC_DECL tvec2<T, P> & operator<<=(tvec1<U, P> const & v);
-		template <typename U> 
-		GLM_FUNC_DECL tvec2<T, P> & operator<<=(tvec2<U, P> const & v);
-		template <typename U> 
-		GLM_FUNC_DECL tvec2<T, P> & operator>>=(U scalar);
-		template <typename U> 
-		GLM_FUNC_DECL tvec2<T, P> & operator>>=(tvec1<U, P> const & v);
-		template <typename U> 
-		GLM_FUNC_DECL tvec2<T, P> & operator>>=(tvec2<U, P> const & v);
+		template<typename U> 
+		GLM_FUNC_DECL vec & operator%=(U scalar);
+		template<typename U> 
+		GLM_FUNC_DECL vec & operator%=(vec<1, U, P> const & v);
+		template<typename U> 
+		GLM_FUNC_DECL vec & operator%=(vec<2, U, P> const & v);
+		template<typename U> 
+		GLM_FUNC_DECL vec & operator&=(U scalar);
+		template<typename U> 
+		GLM_FUNC_DECL vec & operator&=(vec<1, U, P> const & v);
+		template<typename U> 
+		GLM_FUNC_DECL vec & operator&=(vec<2, U, P> const & v);
+		template<typename U> 
+		GLM_FUNC_DECL vec & operator|=(U scalar);
+		template<typename U> 
+		GLM_FUNC_DECL vec & operator|=(vec<1, U, P> const & v);
+		template<typename U> 
+		GLM_FUNC_DECL vec & operator|=(vec<2, U, P> const & v);
+		template<typename U> 
+		GLM_FUNC_DECL vec & operator^=(U scalar);
+		template<typename U> 
+		GLM_FUNC_DECL vec & operator^=(vec<1, U, P> const & v);
+		template<typename U> 
+		GLM_FUNC_DECL vec & operator^=(vec<2, U, P> const & v);
+		template<typename U> 
+		GLM_FUNC_DECL vec & operator<<=(U scalar);
+		template<typename U> 
+		GLM_FUNC_DECL vec & operator<<=(vec<1, U, P> const & v);
+		template<typename U> 
+		GLM_FUNC_DECL vec & operator<<=(vec<2, U, P> const & v);
+		template<typename U> 
+		GLM_FUNC_DECL vec & operator>>=(U scalar);
+		template<typename U> 
+		GLM_FUNC_DECL vec & operator>>=(vec<1, U, P> const & v);
+		template<typename U> 
+		GLM_FUNC_DECL vec & operator>>=(vec<2, U, P> const & v);
 	};
 
 	// -- Unary operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec2<T, P> operator+(tvec2<T, P> const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<2, T, P> operator+(vec<2, T, P> const & v);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec2<T, P> operator-(tvec2<T, P> const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<2, T, P> operator-(vec<2, T, P> const & v);
 
 	// -- Binary operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec2<T, P> operator+(tvec2<T, P> const & v, T scalar);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<2, T, P> operator+(vec<2, T, P> const & v, T scalar);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec2<T, P> operator+(tvec2<T, P> const & v1, tvec1<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<2, T, P> operator+(vec<2, T, P> const & v1, vec<1, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec2<T, P> operator+(T scalar, tvec2<T, P> const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<2, T, P> operator+(T scalar, vec<2, T, P> const & v);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec2<T, P> operator+(tvec1<T, P> const & v1, tvec2<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<2, T, P> operator+(vec<1, T, P> const & v1, vec<2, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec2<T, P> operator+(tvec2<T, P> const & v1, tvec2<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<2, T, P> operator+(vec<2, T, P> const & v1, vec<2, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec2<T, P> operator-(tvec2<T, P> const & v, T scalar);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<2, T, P> operator-(vec<2, T, P> const & v, T scalar);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec2<T, P> operator-(tvec2<T, P> const & v1, tvec1<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<2, T, P> operator-(vec<2, T, P> const & v1, vec<1, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec2<T, P> operator-(T scalar, tvec2<T, P> const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<2, T, P> operator-(T scalar, vec<2, T, P> const & v);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec2<T, P> operator-(tvec1<T, P> const & v1, tvec2<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<2, T, P> operator-(vec<1, T, P> const & v1, vec<2, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec2<T, P> operator-(tvec2<T, P> const & v1, tvec2<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<2, T, P> operator-(vec<2, T, P> const & v1, vec<2, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec2<T, P> operator*(tvec2<T, P> const & v, T scalar);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<2, T, P> operator*(vec<2, T, P> const & v, T scalar);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec2<T, P> operator*(tvec2<T, P> const & v1, tvec1<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<2, T, P> operator*(vec<2, T, P> const & v1, vec<1, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec2<T, P> operator*(T scalar, tvec2<T, P> const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<2, T, P> operator*(T scalar, vec<2, T, P> const & v);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec2<T, P> operator*(tvec1<T, P> const & v1, tvec2<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<2, T, P> operator*(vec<1, T, P> const & v1, vec<2, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec2<T, P> operator*(tvec2<T, P> const & v1, tvec2<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<2, T, P> operator*(vec<2, T, P> const & v1, vec<2, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec2<T, P> operator/(tvec2<T, P> const & v, T scalar);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<2, T, P> operator/(vec<2, T, P> const & v, T scalar);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec2<T, P> operator/(tvec2<T, P> const & v1, tvec1<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<2, T, P> operator/(vec<2, T, P> const & v1, vec<1, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec2<T, P> operator/(T scalar, tvec2<T, P> const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<2, T, P> operator/(T scalar, vec<2, T, P> const & v);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec2<T, P> operator/(tvec1<T, P> const & v1, tvec2<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<2, T, P> operator/(vec<1, T, P> const & v1, vec<2, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec2<T, P> operator/(tvec2<T, P> const & v1, tvec2<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<2, T, P> operator/(vec<2, T, P> const & v1, vec<2, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec2<T, P> operator%(tvec2<T, P> const & v, T scalar);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<2, T, P> operator%(vec<2, T, P> const & v, T scalar);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec2<T, P> operator%(tvec2<T, P> const & v1, tvec1<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<2, T, P> operator%(vec<2, T, P> const & v1, vec<1, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec2<T, P> operator%(T scalar, tvec2<T, P> const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<2, T, P> operator%(T scalar, vec<2, T, P> const & v);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec2<T, P> operator%(tvec1<T, P> const & v1, tvec2<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<2, T, P> operator%(vec<1, T, P> const & v1, vec<2, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec2<T, P> operator%(tvec2<T, P> const & v1, tvec2<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<2, T, P> operator%(vec<2, T, P> const & v1, vec<2, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec2<T, P> operator&(tvec2<T, P> const & v, T scalar);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<2, T, P> operator&(vec<2, T, P> const & v, T scalar);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec2<T, P> operator&(tvec2<T, P> const & v1, tvec1<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<2, T, P> operator&(vec<2, T, P> const & v1, vec<1, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec2<T, P> operator&(T scalar, tvec2<T, P> const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<2, T, P> operator&(T scalar, vec<2, T, P> const & v);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec2<T, P> operator&(tvec1<T, P> const & v1, tvec2<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<2, T, P> operator&(vec<1, T, P> const & v1, vec<2, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec2<T, P> operator&(tvec2<T, P> const & v1, tvec2<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<2, T, P> operator&(vec<2, T, P> const & v1, vec<2, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec2<T, P> operator|(tvec2<T, P> const & v, T scalar);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<2, T, P> operator|(vec<2, T, P> const & v, T scalar);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec2<T, P> operator|(tvec2<T, P> const & v1, tvec1<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<2, T, P> operator|(vec<2, T, P> const & v1, vec<1, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec2<T, P> operator|(T scalar, tvec2<T, P> const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<2, T, P> operator|(T scalar, vec<2, T, P> const & v);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec2<T, P> operator|(tvec1<T, P> const & v1, tvec2<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<2, T, P> operator|(vec<1, T, P> const & v1, vec<2, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec2<T, P> operator|(tvec2<T, P> const & v1, tvec2<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<2, T, P> operator|(vec<2, T, P> const & v1, vec<2, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec2<T, P> operator^(tvec2<T, P> const & v, T scalar);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<2, T, P> operator^(vec<2, T, P> const & v, T scalar);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec2<T, P> operator^(tvec2<T, P> const & v1, tvec1<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<2, T, P> operator^(vec<2, T, P> const & v1, vec<1, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec2<T, P> operator^(T scalar, tvec2<T, P> const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<2, T, P> operator^(T scalar, vec<2, T, P> const & v);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec2<T, P> operator^(tvec1<T, P> const & v1, tvec2<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<2, T, P> operator^(vec<1, T, P> const & v1, vec<2, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec2<T, P> operator^(tvec2<T, P> const & v1, tvec2<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<2, T, P> operator^(vec<2, T, P> const & v1, vec<2, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec2<T, P> operator<<(tvec2<T, P> const & v, T scalar);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<2, T, P> operator<<(vec<2, T, P> const & v, T scalar);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec2<T, P> operator<<(tvec2<T, P> const & v1, tvec1<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<2, T, P> operator<<(vec<2, T, P> const & v1, vec<1, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec2<T, P> operator<<(T scalar, tvec2<T, P> const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<2, T, P> operator<<(T scalar, vec<2, T, P> const & v);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec2<T, P> operator<<(tvec1<T, P> const & v1, tvec2<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<2, T, P> operator<<(vec<1, T, P> const & v1, vec<2, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec2<T, P> operator<<(tvec2<T, P> const & v1, tvec2<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<2, T, P> operator<<(vec<2, T, P> const & v1, vec<2, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec2<T, P> operator>>(tvec2<T, P> const & v, T scalar);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<2, T, P> operator>>(vec<2, T, P> const & v, T scalar);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec2<T, P> operator>>(tvec2<T, P> const & v1, tvec1<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<2, T, P> operator>>(vec<2, T, P> const & v1, vec<1, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec2<T, P> operator>>(T scalar, tvec2<T, P> const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<2, T, P> operator>>(T scalar, vec<2, T, P> const & v);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec2<T, P> operator>>(tvec1<T, P> const & v1, tvec2<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<2, T, P> operator>>(vec<1, T, P> const & v1, vec<2, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec2<T, P> operator>>(tvec2<T, P> const & v1, tvec2<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<2, T, P> operator>>(vec<2, T, P> const & v1, vec<2, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec2<T, P> operator~(tvec2<T, P> const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<2, T, P> operator~(vec<2, T, P> const & v);
 
 	// -- Boolean operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL bool operator==(tvec2<T, P> const & v1, tvec2<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL bool operator==(vec<2, T, P> const & v1, vec<2, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL bool operator!=(tvec2<T, P> const & v1, tvec2<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL bool operator!=(vec<2, T, P> const & v1, vec<2, T, P> const & v2);
 
-	template <precision P>
-	GLM_FUNC_DECL tvec2<bool, P> operator&&(tvec2<bool, P> const & v1, tvec2<bool, P> const & v2);
+	template<precision P>
+	GLM_FUNC_DECL vec<2, bool, P> operator&&(vec<2, bool, P> const & v1, vec<2, bool, P> const & v2);
 
-	template <precision P>
-	GLM_FUNC_DECL tvec2<bool, P> operator||(tvec2<bool, P> const & v1, tvec2<bool, P> const & v2);
+	template<precision P>
+	GLM_FUNC_DECL vec<2, bool, P> operator||(vec<2, bool, P> const & v1, vec<2, bool, P> const & v2);
 }//namespace glm
 
 #ifndef GLM_EXTERNAL_TEMPLATE
diff --git a/glm/detail/type_vec2.inl b/glm/detail/type_vec2.inl
index c7b2c1cb..856c6278 100644
--- a/glm/detail/type_vec2.inl
+++ b/glm/detail/type_vec2.inl
@@ -6,8 +6,8 @@ namespace glm
 	// -- Implicit basic constructors --
 
 #	if !GLM_HAS_DEFAULTED_FUNCTIONS || !defined(GLM_FORCE_NO_CTOR_INIT)
-		template <typename T, precision P>
-		GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec2<T, P>::tvec2()
+		template<typename T, precision P>
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, P>::vec()
 #			ifndef GLM_FORCE_NO_CTOR_INIT
 				: x(0), y(0)
 #			endif
@@ -15,84 +15,84 @@ namespace glm
 #	endif//!GLM_HAS_DEFAULTED_FUNCTIONS
 
 #	if !GLM_HAS_DEFAULTED_FUNCTIONS
-		template <typename T, precision P>
-		GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec2<T, P>::tvec2(tvec2<T, P> const & v)
+		template<typename T, precision P>
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, P>::vec(vec<2, T, P> const & v)
 			: x(v.x), y(v.y)
 		{}
 #	endif//!GLM_HAS_DEFAULTED_FUNCTIONS
 
-	template <typename T, precision P>
-	template <precision Q>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec2<T, P>::tvec2(tvec2<T, Q> const & v)
+	template<typename T, precision P>
+	template<precision Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, P>::vec(vec<2, T, Q> const & v)
 		: x(v.x), y(v.y)
 	{}
 
 	// -- Explicit basic constructors --
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR tvec2<T, P>::tvec2(ctor)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<2, T, P>::vec(ctor)
 	{}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec2<T, P>::tvec2(T scalar)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, P>::vec(T scalar)
 		: x(scalar), y(scalar)
 	{}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec2<T, P>::tvec2(T s1, T s2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, P>::vec(T s1, T s2)
 		: x(s1), y(s2)
 	{}
 
 	// -- Conversion scalar constructors --
 
-	template <typename T, precision P>
-	template <typename A, typename B>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec2<T, P>::tvec2(A a, B b)
+	template<typename T, precision P>
+	template<typename A, typename B>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, P>::vec(A a, B b)
 		: x(static_cast<T>(a))
 		, y(static_cast<T>(b))
 	{}
 
-	template <typename T, precision P>
-	template <typename A, typename B>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec2<T, P>::tvec2(tvec1<A, P> const & a, tvec1<B, P> const & b)
+	template<typename T, precision P>
+	template<typename A, typename B>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, P>::vec(vec<1, A, P> const & a, vec<1, B, P> const & b)
 		: x(static_cast<T>(a.x))
 		, y(static_cast<T>(b.x))
 	{}
 
 	// -- Conversion vector constructors --
 
-	template <typename T, precision P>
-	template <typename U, precision Q>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec2<T, P>::tvec2(tvec2<U, Q> const & v)
+	template<typename T, precision P>
+	template<typename U, precision Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, P>::vec(vec<2, U, Q> const & v)
 		: x(static_cast<T>(v.x))
 		, y(static_cast<T>(v.y))
 	{}
 
-	template <typename T, precision P>
-	template <typename U, precision Q>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec2<T, P>::tvec2(tvec3<U, Q> const & v)
+	template<typename T, precision P>
+	template<typename U, precision Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, P>::vec(vec<3, U, Q> const & v)
 		: x(static_cast<T>(v.x))
 		, y(static_cast<T>(v.y))
 	{}
 
-	template <typename T, precision P>
-	template <typename U, precision Q>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec2<T, P>::tvec2(tvec4<U, Q> const & v)
+	template<typename T, precision P>
+	template<typename U, precision Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, P>::vec(vec<4, U, Q> const & v)
 		: x(static_cast<T>(v.x))
 		, y(static_cast<T>(v.y))
 	{}
 
 	// -- Component accesses --
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER T & tvec2<T, P>::operator[](typename tvec2<T, P>::length_type i)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER T & vec<2, T, P>::operator[](typename vec<2, T, P>::length_type i)
 	{
 		assert(i >= 0 && i < this->length());
 		return (&x)[i];
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER T const & tvec2<T, P>::operator[](typename tvec2<T, P>::length_type i) const
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER T const & vec<2, T, P>::operator[](typename vec<2, T, P>::length_type i) const
 	{
 		assert(i >= 0 && i < this->length());
 		return (&x)[i];
@@ -101,8 +101,8 @@ namespace glm
 	// -- Unary arithmetic operators --
 
 #	if !GLM_HAS_DEFAULTED_FUNCTIONS
-		template <typename T, precision P>
-		GLM_FUNC_QUALIFIER tvec2<T, P> & tvec2<T, P>::operator=(tvec2<T, P> const & v)
+		template<typename T, precision P>
+		GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator=(vec<2, T, P> const & v)
 		{
 			this->x = v.x;
 			this->y = v.y;
@@ -110,117 +110,117 @@ namespace glm
 		}
 #	endif//!GLM_HAS_DEFAULTED_FUNCTIONS
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tvec2<T, P> & tvec2<T, P>::operator=(tvec2<U, P> const & v)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator=(vec<2, U, P> const & v)
 	{
 		this->x = static_cast<T>(v.x);
 		this->y = static_cast<T>(v.y);
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tvec2<T, P> & tvec2<T, P>::operator+=(U scalar)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator+=(U scalar)
 	{
 		this->x += static_cast<T>(scalar);
 		this->y += static_cast<T>(scalar);
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tvec2<T, P> & tvec2<T, P>::operator+=(tvec1<U, P> const & v)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator+=(vec<1, U, P> const & v)
 	{
 		this->x += static_cast<T>(v.x);
 		this->y += static_cast<T>(v.x);
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tvec2<T, P> & tvec2<T, P>::operator+=(tvec2<U, P> const & v)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator+=(vec<2, U, P> const & v)
 	{
 		this->x += static_cast<T>(v.x);
 		this->y += static_cast<T>(v.y);
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tvec2<T, P> & tvec2<T, P>::operator-=(U scalar)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator-=(U scalar)
 	{
 		this->x -= static_cast<T>(scalar);
 		this->y -= static_cast<T>(scalar);
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tvec2<T, P> & tvec2<T, P>::operator-=(tvec1<U, P> const & v)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator-=(vec<1, U, P> const & v)
 	{
 		this->x -= static_cast<T>(v.x);
 		this->y -= static_cast<T>(v.x);
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tvec2<T, P> & tvec2<T, P>::operator-=(tvec2<U, P> const & v)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator-=(vec<2, U, P> const & v)
 	{
 		this->x -= static_cast<T>(v.x);
 		this->y -= static_cast<T>(v.y);
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tvec2<T, P> & tvec2<T, P>::operator*=(U scalar)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator*=(U scalar)
 	{
 		this->x *= static_cast<T>(scalar);
 		this->y *= static_cast<T>(scalar);
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tvec2<T, P> & tvec2<T, P>::operator*=(tvec1<U, P> const & v)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator*=(vec<1, U, P> const & v)
 	{
 		this->x *= static_cast<T>(v.x);
 		this->y *= static_cast<T>(v.x);
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tvec2<T, P> & tvec2<T, P>::operator*=(tvec2<U, P> const & v)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator*=(vec<2, U, P> const & v)
 	{
 		this->x *= static_cast<T>(v.x);
 		this->y *= static_cast<T>(v.y);
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tvec2<T, P> & tvec2<T, P>::operator/=(U scalar)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator/=(U scalar)
 	{
 		this->x /= static_cast<T>(scalar);
 		this->y /= static_cast<T>(scalar);
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tvec2<T, P> & tvec2<T, P>::operator/=(tvec1<U, P> const & v)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator/=(vec<1, U, P> const & v)
 	{
 		this->x /= static_cast<T>(v.x);
 		this->y /= static_cast<T>(v.x);
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tvec2<T, P> & tvec2<T, P>::operator/=(tvec2<U, P> const & v)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator/=(vec<2, U, P> const & v)
 	{
 		this->x /= static_cast<T>(v.x);
 		this->y /= static_cast<T>(v.y);
@@ -229,196 +229,196 @@ namespace glm
 
 	// -- Increment and decrement operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P> & tvec2<T, P>::operator++()
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator++()
 	{
 		++this->x;
 		++this->y;
 		return *this;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P> & tvec2<T, P>::operator--()
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator--()
 	{
 		--this->x;
 		--this->y;
 		return *this;
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tvec2<T, P> tvec2<T, P>::operator++(int)
+	template<typename T, precision P> 
+	GLM_FUNC_QUALIFIER vec<2, T, P> vec<2, T, P>::operator++(int)
 	{
-		tvec2<T, P> Result(*this);
+		vec<2, T, P> Result(*this);
 		++*this;
 		return Result;
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tvec2<T, P> tvec2<T, P>::operator--(int)
+	template<typename T, precision P> 
+	GLM_FUNC_QUALIFIER vec<2, T, P> vec<2, T, P>::operator--(int)
 	{
-		tvec2<T, P> Result(*this);
+		vec<2, T, P> Result(*this);
 		--*this;
 		return Result;
 	}
 
 	// -- Unary bit operators --
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tvec2<T, P> & tvec2<T, P>::operator%=(U scalar)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator%=(U scalar)
 	{
 		this->x %= static_cast<T>(scalar);
 		this->y %= static_cast<T>(scalar);
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tvec2<T, P> & tvec2<T, P>::operator%=(tvec1<U, P> const & v)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator%=(vec<1, U, P> const & v)
 	{
 		this->x %= static_cast<T>(v.x);
 		this->y %= static_cast<T>(v.x);
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tvec2<T, P> & tvec2<T, P>::operator%=(tvec2<U, P> const & v)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator%=(vec<2, U, P> const & v)
 	{
 		this->x %= static_cast<T>(v.x);
 		this->y %= static_cast<T>(v.y);
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tvec2<T, P> & tvec2<T, P>::operator&=(U scalar)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator&=(U scalar)
 	{
 		this->x &= static_cast<T>(scalar);
 		this->y &= static_cast<T>(scalar);
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tvec2<T, P> & tvec2<T, P>::operator&=(tvec1<U, P> const & v)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator&=(vec<1, U, P> const & v)
 	{
 		this->x &= static_cast<T>(v.x);
 		this->y &= static_cast<T>(v.x);
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tvec2<T, P> & tvec2<T, P>::operator&=(tvec2<U, P> const & v)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator&=(vec<2, U, P> const & v)
 	{
 		this->x &= static_cast<T>(v.x);
 		this->y &= static_cast<T>(v.y);
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tvec2<T, P> & tvec2<T, P>::operator|=(U scalar)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator|=(U scalar)
 	{
 		this->x |= static_cast<T>(scalar);
 		this->y |= static_cast<T>(scalar);
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tvec2<T, P> & tvec2<T, P>::operator|=(tvec1<U, P> const & v)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator|=(vec<1, U, P> const & v)
 	{
 		this->x |= static_cast<T>(v.x);
 		this->y |= static_cast<T>(v.x);
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tvec2<T, P> & tvec2<T, P>::operator|=(tvec2<U, P> const & v)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator|=(vec<2, U, P> const & v)
 	{
 		this->x |= static_cast<T>(v.x);
 		this->y |= static_cast<T>(v.y);
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tvec2<T, P> & tvec2<T, P>::operator^=(U scalar)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator^=(U scalar)
 	{
 		this->x ^= static_cast<T>(scalar);
 		this->y ^= static_cast<T>(scalar);
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tvec2<T, P> & tvec2<T, P>::operator^=(tvec1<U, P> const & v)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator^=(vec<1, U, P> const & v)
 	{
 		this->x ^= static_cast<T>(v.x);
 		this->y ^= static_cast<T>(v.x);
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tvec2<T, P> & tvec2<T, P>::operator^=(tvec2<U, P> const & v)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator^=(vec<2, U, P> const & v)
 	{
 		this->x ^= static_cast<T>(v.x);
 		this->y ^= static_cast<T>(v.y);
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tvec2<T, P> & tvec2<T, P>::operator<<=(U scalar)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator<<=(U scalar)
 	{
 		this->x <<= static_cast<T>(scalar);
 		this->y <<= static_cast<T>(scalar);
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tvec2<T, P> & tvec2<T, P>::operator<<=(tvec1<U, P> const & v)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator<<=(vec<1, U, P> const & v)
 	{
 		this->x <<= static_cast<T>(v.x);
 		this->y <<= static_cast<T>(v.x);
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tvec2<T, P> & tvec2<T, P>::operator<<=(tvec2<U, P> const & v)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator<<=(vec<2, U, P> const & v)
 	{
 		this->x <<= static_cast<T>(v.x);
 		this->y <<= static_cast<T>(v.y);
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tvec2<T, P> & tvec2<T, P>::operator>>=(U scalar)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator>>=(U scalar)
 	{
 		this->x >>= static_cast<T>(scalar);
 		this->y >>= static_cast<T>(scalar);
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tvec2<T, P> & tvec2<T, P>::operator>>=(tvec1<U, P> const & v)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator>>=(vec<1, U, P> const & v)
 	{
 		this->x >>= static_cast<T>(v.x);
 		this->y >>= static_cast<T>(v.x);
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tvec2<T, P> & tvec2<T, P>::operator>>=(tvec2<U, P> const & v)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator>>=(vec<2, U, P> const & v)
 	{
 		this->x >>= static_cast<T>(v.x);
 		this->y >>= static_cast<T>(v.y);
@@ -427,455 +427,455 @@ namespace glm
 
 	// -- Unary arithmetic operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P> operator+(tvec2<T, P> const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<2, T, P> operator+(vec<2, T, P> const & v)
 	{
 		return v;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P> operator-(tvec2<T, P> const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<2, T, P> operator-(vec<2, T, P> const & v)
 	{
-		return tvec2<T, P>(
+		return vec<2, T, P>(
 			-v.x, 
 			-v.y);
 	}
 
 	// -- Binary arithmetic operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P> operator+(tvec2<T, P> const & v, T scalar)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<2, T, P> operator+(vec<2, T, P> const & v, T scalar)
 	{
-		return tvec2<T, P>(
+		return vec<2, T, P>(
 			v.x + scalar,
 			v.y + scalar);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P> operator+(tvec2<T, P> const & v1, tvec1<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<2, T, P> operator+(vec<2, T, P> const & v1, vec<1, T, P> const & v2)
 	{
-		return tvec2<T, P>(
+		return vec<2, T, P>(
 			v1.x + v2.x,
 			v1.y + v2.x);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P> operator+(T scalar, tvec2<T, P> const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<2, T, P> operator+(T scalar, vec<2, T, P> const & v)
 	{
-		return tvec2<T, P>(
+		return vec<2, T, P>(
 			scalar + v.x,
 			scalar + v.y);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P> operator+(tvec1<T, P> const & v1, tvec2<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<2, T, P> operator+(vec<1, T, P> const & v1, vec<2, T, P> const & v2)
 	{
-		return tvec2<T, P>(
+		return vec<2, T, P>(
 			v1.x + v2.x,
 			v1.x + v2.y);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P> operator+(tvec2<T, P> const & v1, tvec2<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<2, T, P> operator+(vec<2, T, P> const & v1, vec<2, T, P> const & v2)
 	{
-		return tvec2<T, P>(
+		return vec<2, T, P>(
 			v1.x + v2.x,
 			v1.y + v2.y);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P> operator-(tvec2<T, P> const & v, T scalar)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<2, T, P> operator-(vec<2, T, P> const & v, T scalar)
 	{
-		return tvec2<T, P>(
+		return vec<2, T, P>(
 			v.x - scalar,
 			v.y - scalar);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P> operator-(tvec2<T, P> const & v1, tvec1<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<2, T, P> operator-(vec<2, T, P> const & v1, vec<1, T, P> const & v2)
 	{
-		return tvec2<T, P>(
+		return vec<2, T, P>(
 			v1.x - v2.x,
 			v1.y - v2.x);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P> operator-(T scalar, tvec2<T, P> const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<2, T, P> operator-(T scalar, vec<2, T, P> const & v)
 	{
-		return tvec2<T, P>(
+		return vec<2, T, P>(
 			scalar - v.x,
 			scalar - v.y);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P> operator-(tvec1<T, P> const & v1, tvec2<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<2, T, P> operator-(vec<1, T, P> const & v1, vec<2, T, P> const & v2)
 	{
-		return tvec2<T, P>(
+		return vec<2, T, P>(
 			v1.x - v2.x,
 			v1.x - v2.y);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P> operator-(tvec2<T, P> const & v1, tvec2<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<2, T, P> operator-(vec<2, T, P> const & v1, vec<2, T, P> const & v2)
 	{
-		return tvec2<T, P>(
+		return vec<2, T, P>(
 			v1.x - v2.x,
 			v1.y - v2.y);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P> operator*(tvec2<T, P> const & v, T scalar)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<2, T, P> operator*(vec<2, T, P> const & v, T scalar)
 	{
-		return tvec2<T, P>(
+		return vec<2, T, P>(
 			v.x * scalar,
 			v.y * scalar);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P> operator*(tvec2<T, P> const & v1, tvec1<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<2, T, P> operator*(vec<2, T, P> const & v1, vec<1, T, P> const & v2)
 	{
-		return tvec2<T, P>(
+		return vec<2, T, P>(
 			v1.x * v2.x,
 			v1.y * v2.x);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P> operator*(T scalar, tvec2<T, P> const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<2, T, P> operator*(T scalar, vec<2, T, P> const & v)
 	{
-		return tvec2<T, P>(
+		return vec<2, T, P>(
 			scalar * v.x,
 			scalar * v.y);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P> operator*(tvec1<T, P> const & v1, tvec2<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<2, T, P> operator*(vec<1, T, P> const & v1, vec<2, T, P> const & v2)
 	{
-		return tvec2<T, P>(
+		return vec<2, T, P>(
 			v1.x * v2.x,
 			v1.x * v2.y);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P> operator*(tvec2<T, P> const & v1, tvec2<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<2, T, P> operator*(vec<2, T, P> const & v1, vec<2, T, P> const & v2)
 	{
-		return tvec2<T, P>(
+		return vec<2, T, P>(
 			v1.x * v2.x,
 			v1.y * v2.y);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P> operator/(tvec2<T, P> const & v, T scalar)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<2, T, P> operator/(vec<2, T, P> const & v, T scalar)
 	{
-		return tvec2<T, P>(
+		return vec<2, T, P>(
 			v.x / scalar,
 			v.y / scalar);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P> operator/(tvec2<T, P> const & v1, tvec1<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<2, T, P> operator/(vec<2, T, P> const & v1, vec<1, T, P> const & v2)
 	{
-		return tvec2<T, P>(
+		return vec<2, T, P>(
 			v1.x / v2.x,
 			v1.y / v2.x);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P> operator/(T scalar, tvec2<T, P> const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<2, T, P> operator/(T scalar, vec<2, T, P> const & v)
 	{
-		return tvec2<T, P>(
+		return vec<2, T, P>(
 			scalar / v.x,
 			scalar / v.y);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P> operator/(tvec1<T, P> const & v1, tvec2<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<2, T, P> operator/(vec<1, T, P> const & v1, vec<2, T, P> const & v2)
 	{
-		return tvec2<T, P>(
+		return vec<2, T, P>(
 			v1.x / v2.x,
 			v1.x / v2.y);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P> operator/(tvec2<T, P> const & v1, tvec2<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<2, T, P> operator/(vec<2, T, P> const & v1, vec<2, T, P> const & v2)
 	{
-		return tvec2<T, P>(
+		return vec<2, T, P>(
 			v1.x / v2.x,
 			v1.y / v2.y);
 	}
 
 	// -- Binary bit operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P> operator%(tvec2<T, P> const & v, T scalar)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<2, T, P> operator%(vec<2, T, P> const & v, T scalar)
 	{
-		return tvec2<T, P>(
+		return vec<2, T, P>(
 			v.x % scalar,
 			v.y % scalar);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P> operator%(tvec2<T, P> const & v1, tvec1<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<2, T, P> operator%(vec<2, T, P> const & v1, vec<1, T, P> const & v2)
 	{
-		return tvec2<T, P>(
+		return vec<2, T, P>(
 			v1.x % v2.x,
 			v1.y % v2.x);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P> operator%(T scalar, tvec2<T, P> const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<2, T, P> operator%(T scalar, vec<2, T, P> const & v)
 	{
-		return tvec2<T, P>(
+		return vec<2, T, P>(
 			scalar % v.x,
 			scalar % v.y);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P> operator%(tvec1<T, P> const & v1, tvec2<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<2, T, P> operator%(vec<1, T, P> const & v1, vec<2, T, P> const & v2)
 	{
-		return tvec2<T, P>(
+		return vec<2, T, P>(
 			v1.x % v2.x,
 			v1.x % v2.y);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P> operator%(tvec2<T, P> const & v1, tvec2<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<2, T, P> operator%(vec<2, T, P> const & v1, vec<2, T, P> const & v2)
 	{
-		return tvec2<T, P>(
+		return vec<2, T, P>(
 			v1.x % v2.x,
 			v1.y % v2.y);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P> operator&(tvec2<T, P> const & v, T scalar)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<2, T, P> operator&(vec<2, T, P> const & v, T scalar)
 	{
-		return tvec2<T, P>(
+		return vec<2, T, P>(
 			v.x & scalar,
 			v.y & scalar);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P> operator&(tvec2<T, P> const & v1, tvec1<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<2, T, P> operator&(vec<2, T, P> const & v1, vec<1, T, P> const & v2)
 	{
-		return tvec2<T, P>(
+		return vec<2, T, P>(
 			v1.x & v2.x,
 			v1.y & v2.x);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P> operator&(T scalar, tvec2<T, P> const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<2, T, P> operator&(T scalar, vec<2, T, P> const & v)
 	{
-		return tvec2<T, P>(
+		return vec<2, T, P>(
 			scalar & v.x,
 			scalar & v.y);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P> operator&(tvec1<T, P> const & v1, tvec2<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<2, T, P> operator&(vec<1, T, P> const & v1, vec<2, T, P> const & v2)
 	{
-		return tvec2<T, P>(
+		return vec<2, T, P>(
 			v1.x & v2.x,
 			v1.x & v2.y);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P> operator&(tvec2<T, P> const & v1, tvec2<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<2, T, P> operator&(vec<2, T, P> const & v1, vec<2, T, P> const & v2)
 	{
-		return tvec2<T, P>(
+		return vec<2, T, P>(
 			v1.x & v2.x,
 			v1.y & v2.y);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P> operator|(tvec2<T, P> const & v, T scalar)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<2, T, P> operator|(vec<2, T, P> const & v, T scalar)
 	{
-		return tvec2<T, P>(
+		return vec<2, T, P>(
 			v.x | scalar,
 			v.y | scalar);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P> operator|(tvec2<T, P> const & v1, tvec1<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<2, T, P> operator|(vec<2, T, P> const & v1, vec<1, T, P> const & v2)
 	{
-		return tvec2<T, P>(
+		return vec<2, T, P>(
 			v1.x | v2.x,
 			v1.y | v2.x);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P> operator|(T scalar, tvec2<T, P> const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<2, T, P> operator|(T scalar, vec<2, T, P> const & v)
 	{
-		return tvec2<T, P>(
+		return vec<2, T, P>(
 			scalar | v.x,
 			scalar | v.y);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P> operator|(tvec1<T, P> const & v1, tvec2<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<2, T, P> operator|(vec<1, T, P> const & v1, vec<2, T, P> const & v2)
 	{
-		return tvec2<T, P>(
+		return vec<2, T, P>(
 			v1.x | v2.x,
 			v1.x | v2.y);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P> operator|(tvec2<T, P> const & v1, tvec2<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<2, T, P> operator|(vec<2, T, P> const & v1, vec<2, T, P> const & v2)
 	{
-		return tvec2<T, P>(
+		return vec<2, T, P>(
 			v1.x | v2.x,
 			v1.y | v2.y);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P> operator^(tvec2<T, P> const & v, T scalar)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<2, T, P> operator^(vec<2, T, P> const & v, T scalar)
 	{
-		return tvec2<T, P>(
+		return vec<2, T, P>(
 			v.x ^ scalar,
 			v.y ^ scalar);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P> operator^(tvec2<T, P> const & v1, tvec1<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<2, T, P> operator^(vec<2, T, P> const & v1, vec<1, T, P> const & v2)
 	{
-		return tvec2<T, P>(
+		return vec<2, T, P>(
 			v1.x ^ v2.x,
 			v1.y ^ v2.x);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P> operator^(T scalar, tvec2<T, P> const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<2, T, P> operator^(T scalar, vec<2, T, P> const & v)
 	{
-		return tvec2<T, P>(
+		return vec<2, T, P>(
 			scalar ^ v.x,
 			scalar ^ v.y);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P> operator^(tvec1<T, P> const & v1, tvec2<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<2, T, P> operator^(vec<1, T, P> const & v1, vec<2, T, P> const & v2)
 	{
-		return tvec2<T, P>(
+		return vec<2, T, P>(
 			v1.x ^ v2.x,
 			v1.x ^ v2.y);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P> operator^(tvec2<T, P> const & v1, tvec2<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<2, T, P> operator^(vec<2, T, P> const & v1, vec<2, T, P> const & v2)
 	{
-		return tvec2<T, P>(
+		return vec<2, T, P>(
 			v1.x ^ v2.x,
 			v1.y ^ v2.y);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P> operator<<(tvec2<T, P> const & v, T scalar)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<2, T, P> operator<<(vec<2, T, P> const & v, T scalar)
 	{
-		return tvec2<T, P>(
+		return vec<2, T, P>(
 			v.x << scalar,
 			v.y << scalar);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P> operator<<(tvec2<T, P> const & v1, tvec1<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<2, T, P> operator<<(vec<2, T, P> const & v1, vec<1, T, P> const & v2)
 	{
-		return tvec2<T, P>(
+		return vec<2, T, P>(
 			v1.x << v2.x,
 			v1.y << v2.x);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P> operator<<(T scalar, tvec2<T, P> const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<2, T, P> operator<<(T scalar, vec<2, T, P> const & v)
 	{
-		return tvec2<T, P>(
+		return vec<2, T, P>(
 			scalar << v.x,
 			scalar << v.y);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P> operator<<(tvec1<T, P> const & v1, tvec2<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<2, T, P> operator<<(vec<1, T, P> const & v1, vec<2, T, P> const & v2)
 	{
-		return tvec2<T, P>(
+		return vec<2, T, P>(
 			v1.x << v2.x,
 			v1.x << v2.y);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P> operator<<(tvec2<T, P> const & v1, tvec2<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<2, T, P> operator<<(vec<2, T, P> const & v1, vec<2, T, P> const & v2)
 	{
-		return tvec2<T, P>(
+		return vec<2, T, P>(
 			v1.x << v2.x,
 			v1.y << v2.y);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P> operator>>(tvec2<T, P> const & v, T scalar)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<2, T, P> operator>>(vec<2, T, P> const & v, T scalar)
 	{
-		return tvec2<T, P>(
+		return vec<2, T, P>(
 			v.x >> scalar,
 			v.y >> scalar);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P> operator>>(tvec2<T, P> const & v1, tvec1<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<2, T, P> operator>>(vec<2, T, P> const & v1, vec<1, T, P> const & v2)
 	{
-		return tvec2<T, P>(
+		return vec<2, T, P>(
 			v1.x >> v2.x,
 			v1.y >> v2.x);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P> operator>>(T scalar, tvec2<T, P> const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<2, T, P> operator>>(T scalar, vec<2, T, P> const & v)
 	{
-		return tvec2<T, P>(
+		return vec<2, T, P>(
 			scalar >> v.x,
 			scalar >> v.y);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P> operator>>(tvec1<T, P> const & v1, tvec2<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<2, T, P> operator>>(vec<1, T, P> const & v1, vec<2, T, P> const & v2)
 	{
-		return tvec2<T, P>(
+		return vec<2, T, P>(
 			v1.x >> v2.x,
 			v1.x >> v2.y);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P> operator>>(tvec2<T, P> const & v1, tvec2<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<2, T, P> operator>>(vec<2, T, P> const & v1, vec<2, T, P> const & v2)
 	{
-		return tvec2<T, P>(
+		return vec<2, T, P>(
 			v1.x >> v2.x,
 			v1.y >> v2.y);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P> operator~(tvec2<T, P> const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<2, T, P> operator~(vec<2, T, P> const & v)
 	{
-		return tvec2<T, P>(
+		return vec<2, T, P>(
 			~v.x,
 			~v.y);
 	}
 
 	// -- Boolean operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER bool operator==(tvec2<T, P> const & v1, tvec2<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER bool operator==(vec<2, T, P> const & v1, vec<2, T, P> const & v2)
 	{
 		return (v1.x == v2.x) && (v1.y == v2.y);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER bool operator!=(tvec2<T, P> const & v1, tvec2<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER bool operator!=(vec<2, T, P> const & v1, vec<2, T, P> const & v2)
 	{
 		return (v1.x != v2.x) || (v1.y != v2.y);
 	}
 
-	template <precision P>
-	GLM_FUNC_QUALIFIER tvec2<bool, P> operator&&(tvec2<bool, P> const & v1, tvec2<bool, P> const & v2)
+	template<precision P>
+	GLM_FUNC_QUALIFIER vec<2, bool, P> operator&&(vec<2, bool, P> const & v1, vec<2, bool, P> const & v2)
 	{
-		return tvec2<bool, P>(v1.x && v2.x, v1.y && v2.y);
+		return vec<2, bool, P>(v1.x && v2.x, v1.y && v2.y);
 	}
 
-	template <precision P>
-	GLM_FUNC_QUALIFIER tvec2<bool, P> operator||(tvec2<bool, P> const & v1, tvec2<bool, P> const & v2)
+	template<precision P>
+	GLM_FUNC_QUALIFIER vec<2, bool, P> operator||(vec<2, bool, P> const & v1, vec<2, bool, P> const & v2)
 	{
-		return tvec2<bool, P>(v1.x || v2.x, v1.y || v2.y);
+		return vec<2, bool, P>(v1.x || v2.x, v1.y || v2.y);
 	}
 }//namespace glm
diff --git a/glm/detail/type_vec3.hpp b/glm/detail/type_vec3.hpp
index 4fcb9643..c3ca1ca9 100644
--- a/glm/detail/type_vec3.hpp
+++ b/glm/detail/type_vec3.hpp
@@ -15,14 +15,14 @@
 
 namespace glm
 {
-	template <typename T, precision P = defaultp>
-	struct tvec3
+	template<typename T, precision P>
+	struct vec<3, T, P>
 	{
 		// -- Implementation detail --
 
 		typedef T value_type;
-		typedef tvec3<T, P> type;
-		typedef tvec3<bool, P> bool_type;
+		typedef vec type;
+		typedef vec<3, bool, P> bool_type;
 
 		// -- Data --
 
@@ -44,15 +44,15 @@ namespace glm
 				struct{ T s, t, p; };
 
 #				if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED
-					_GLM_SWIZZLE3_2_MEMBERS(T, P, glm::tvec2, x, y, z)
-					_GLM_SWIZZLE3_2_MEMBERS(T, P, glm::tvec2, r, g, b)
-					_GLM_SWIZZLE3_2_MEMBERS(T, P, glm::tvec2, s, t, p)
-					_GLM_SWIZZLE3_3_MEMBERS(T, P, glm::tvec3, x, y, z)
-					_GLM_SWIZZLE3_3_MEMBERS(T, P, glm::tvec3, r, g, b)
-					_GLM_SWIZZLE3_3_MEMBERS(T, P, glm::tvec3, s, t, p)
-					_GLM_SWIZZLE3_4_MEMBERS(T, P, glm::tvec4, x, y, z)
-					_GLM_SWIZZLE3_4_MEMBERS(T, P, glm::tvec4, r, g, b)
-					_GLM_SWIZZLE3_4_MEMBERS(T, P, glm::tvec4, s, t, p)
+					_GLM_SWIZZLE3_2_MEMBERS(T, P, x, y, z)
+					_GLM_SWIZZLE3_2_MEMBERS(T, P, r, g, b)
+					_GLM_SWIZZLE3_2_MEMBERS(T, P, s, t, p)
+					_GLM_SWIZZLE3_3_MEMBERS(T, P, x, y, z)
+					_GLM_SWIZZLE3_3_MEMBERS(T, P, r, g, b)
+					_GLM_SWIZZLE3_3_MEMBERS(T, P, s, t, p)
+					_GLM_SWIZZLE3_4_MEMBERS(T, P, x, y, z)
+					_GLM_SWIZZLE3_4_MEMBERS(T, P, r, g, b)
+					_GLM_SWIZZLE3_4_MEMBERS(T, P, s, t, p)
 #				endif//GLM_SWIZZLE
 			};
 		
@@ -68,7 +68,7 @@ namespace glm
 			union { T z, b, p; };
 
 #			if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED
-				GLM_SWIZZLE_GEN_VEC_FROM_VEC3(T, P, tvec3, tvec2, tvec3, tvec4)
+				GLM_SWIZZLE_GEN_VEC_FROM_VEC3(T, P)
 #			endif//GLM_SWIZZLE
 #		endif//GLM_LANG
 
@@ -83,322 +83,322 @@ namespace glm
 
 		// -- Implicit basic constructors --
 
-		GLM_FUNC_DECL GLM_CONSTEXPR tvec3() GLM_DEFAULT_CTOR;
-		GLM_FUNC_DECL GLM_CONSTEXPR tvec3(tvec3<T, P> const & v) GLM_DEFAULT;
-		template <precision Q>
-		GLM_FUNC_DECL GLM_CONSTEXPR tvec3(tvec3<T, Q> const & v);
+		GLM_FUNC_DECL GLM_CONSTEXPR vec() GLM_DEFAULT_CTOR;
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec const & v) GLM_DEFAULT;
+		template<precision Q>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<3, T, Q> const & v);
 
 		// -- Explicit basic constructors --
 
-		GLM_FUNC_DECL GLM_CONSTEXPR_CTOR explicit tvec3(ctor);
-		GLM_FUNC_DECL GLM_CONSTEXPR explicit tvec3(T scalar);
-		GLM_FUNC_DECL GLM_CONSTEXPR tvec3(T a, T b, T c);
+		GLM_FUNC_DECL GLM_CONSTEXPR_CTOR explicit vec(ctor);
+		GLM_FUNC_DECL GLM_CONSTEXPR explicit vec(T scalar);
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(T a, T b, T c);
 
 		// -- Conversion scalar constructors --
 
 		/// Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename A, typename B, typename C>
-		GLM_FUNC_DECL GLM_CONSTEXPR tvec3(A a, B b, C c);
-		template <typename A, typename B, typename C>
-		GLM_FUNC_DECL GLM_CONSTEXPR tvec3(tvec1<A, P> const & a, tvec1<B, P> const & b, tvec1<C, P> const & c);
+		template<typename A, typename B, typename C>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(A a, B b, C c);
+		template<typename A, typename B, typename C>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, A, P> const & a, vec<1, B, P> const & b, vec<1, C, P> const & c);
 
 		// -- Conversion vector constructors --
 
 		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename A, typename B, precision Q>
-		GLM_FUNC_DECL GLM_CONSTEXPR tvec3(tvec2<A, Q> const & a, B b);
+		template<typename A, typename B, precision Q>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<2, A, Q> const & a, B b);
 		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename A, typename B, precision Q>
-		GLM_FUNC_DECL GLM_CONSTEXPR tvec3(tvec2<A, Q> const & a, tvec1<B, Q> const & b);
+		template<typename A, typename B, precision Q>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<2, A, Q> const & a, vec<1, B, Q> const & b);
 		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename A, typename B, precision Q>
-		GLM_FUNC_DECL GLM_CONSTEXPR tvec3(A a, tvec2<B, Q> const & b);
+		template<typename A, typename B, precision Q>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(A a, vec<2, B, Q> const & b);
 		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename A, typename B, precision Q>
-		GLM_FUNC_DECL GLM_CONSTEXPR tvec3(tvec1<A, Q> const & a, tvec2<B, Q> const & b);
+		template<typename A, typename B, precision Q>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, A, Q> const & a, vec<2, B, Q> const & b);
 		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename U, precision Q>
-		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tvec3(tvec4<U, Q> const & v);
+		template<typename U, precision Q>
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT vec(vec<4, U, Q> const & v);
 
 		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename U, precision Q>
-		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tvec3(tvec3<U, Q> const & v);
+		template<typename U, precision Q>
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT vec(vec<3, U, Q> const & v);
 
 		// -- Swizzle constructors --
 #		if GLM_HAS_UNRESTRICTED_UNIONS && (GLM_SWIZZLE == GLM_SWIZZLE_ENABLED)
-			template <int E0, int E1, int E2>
-			GLM_FUNC_DECL tvec3(detail::_swizzle<3, T, P, glm::tvec3, E0, E1, E2, -1> const & that)
+			template<int E0, int E1, int E2>
+			GLM_FUNC_DECL vec(detail::_swizzle<3, T, P, E0, E1, E2, -1> const & that)
 			{
 				*this = that();
 			}
 
-			template <int E0, int E1>
-			GLM_FUNC_DECL tvec3(detail::_swizzle<2, T, P, glm::tvec2, E0, E1, -1, -2> const & v, T const & scalar)
+			template<int E0, int E1>
+			GLM_FUNC_DECL vec(detail::_swizzle<2, T, P, E0, E1, -1, -2> const & v, T const & scalar)
 			{
-				*this = tvec3<T, P>(v(), scalar);
+				*this = vec(v(), scalar);
 			}
 
-			template <int E0, int E1>
-			GLM_FUNC_DECL tvec3(T const & scalar, detail::_swizzle<2, T, P, glm::tvec2, E0, E1, -1, -2> const & v)
+			template<int E0, int E1>
+			GLM_FUNC_DECL vec(T const & scalar, detail::_swizzle<2, T, P, E0, E1, -1, -2> const & v)
 			{
-				*this = tvec3<T, P>(scalar, v());
+				*this = vec(scalar, v());
 			}
 #		endif// GLM_HAS_UNRESTRICTED_UNIONS && (GLM_SWIZZLE == GLM_SWIZZLE_ENABLED)
 
 		// -- Unary arithmetic operators --
 
-		GLM_FUNC_DECL tvec3<T, P> & operator=(tvec3<T, P> const & v) GLM_DEFAULT;
+		GLM_FUNC_DECL vec & operator=(vec const & v) GLM_DEFAULT;
 
-		template <typename U>
-		GLM_FUNC_DECL tvec3<T, P> & operator=(tvec3<U, P> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec3<T, P> & operator+=(U scalar);
-		template <typename U>
-		GLM_FUNC_DECL tvec3<T, P> & operator+=(tvec1<U, P> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec3<T, P> & operator+=(tvec3<U, P> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec3<T, P> & operator-=(U scalar);
-		template <typename U>
-		GLM_FUNC_DECL tvec3<T, P> & operator-=(tvec1<U, P> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec3<T, P> & operator-=(tvec3<U, P> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec3<T, P> & operator*=(U scalar);
-		template <typename U>
-		GLM_FUNC_DECL tvec3<T, P> & operator*=(tvec1<U, P> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec3<T, P> & operator*=(tvec3<U, P> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec3<T, P> & operator/=(U scalar);
-		template <typename U>
-		GLM_FUNC_DECL tvec3<T, P> & operator/=(tvec1<U, P> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec3<T, P> & operator/=(tvec3<U, P> const & v);
+		template<typename U>
+		GLM_FUNC_DECL vec & operator=(vec<3, U, P> const & v);
+		template<typename U>
+		GLM_FUNC_DECL vec & operator+=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL vec & operator+=(vec<1, U, P> const & v);
+		template<typename U>
+		GLM_FUNC_DECL vec & operator+=(vec<3, U, P> const & v);
+		template<typename U>
+		GLM_FUNC_DECL vec & operator-=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL vec & operator-=(vec<1, U, P> const & v);
+		template<typename U>
+		GLM_FUNC_DECL vec & operator-=(vec<3, U, P> const & v);
+		template<typename U>
+		GLM_FUNC_DECL vec & operator*=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL vec & operator*=(vec<1, U, P> const & v);
+		template<typename U>
+		GLM_FUNC_DECL vec & operator*=(vec<3, U, P> const & v);
+		template<typename U>
+		GLM_FUNC_DECL vec & operator/=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL vec & operator/=(vec<1, U, P> const & v);
+		template<typename U>
+		GLM_FUNC_DECL vec & operator/=(vec<3, U, P> const & v);
 
 		// -- Increment and decrement operators --
 
-		GLM_FUNC_DECL tvec3<T, P> & operator++();
-		GLM_FUNC_DECL tvec3<T, P> & operator--();
-		GLM_FUNC_DECL tvec3<T, P> operator++(int);
-		GLM_FUNC_DECL tvec3<T, P> operator--(int);
+		GLM_FUNC_DECL vec & operator++();
+		GLM_FUNC_DECL vec & operator--();
+		GLM_FUNC_DECL vec operator++(int);
+		GLM_FUNC_DECL vec operator--(int);
 
 		// -- Unary bit operators --
 
-		template <typename U>
-		GLM_FUNC_DECL tvec3<T, P> & operator%=(U scalar);
-		template <typename U>
-		GLM_FUNC_DECL tvec3<T, P> & operator%=(tvec1<U, P> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec3<T, P> & operator%=(tvec3<U, P> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec3<T, P> & operator&=(U scalar);
-		template <typename U>
-		GLM_FUNC_DECL tvec3<T, P> & operator&=(tvec1<U, P> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec3<T, P> & operator&=(tvec3<U, P> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec3<T, P> & operator|=(U scalar);
-		template <typename U>
-		GLM_FUNC_DECL tvec3<T, P> & operator|=(tvec1<U, P> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec3<T, P> & operator|=(tvec3<U, P> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec3<T, P> & operator^=(U scalar);
-		template <typename U>
-		GLM_FUNC_DECL tvec3<T, P> & operator^=(tvec1<U, P> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec3<T, P> & operator^=(tvec3<U, P> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec3<T, P> & operator<<=(U scalar);
-		template <typename U>
-		GLM_FUNC_DECL tvec3<T, P> & operator<<=(tvec1<U, P> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec3<T, P> & operator<<=(tvec3<U, P> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec3<T, P> & operator>>=(U scalar);
-		template <typename U>
-		GLM_FUNC_DECL tvec3<T, P> & operator>>=(tvec1<U, P> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec3<T, P> & operator>>=(tvec3<U, P> const & v);
+		template<typename U>
+		GLM_FUNC_DECL vec & operator%=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL vec & operator%=(vec<1, U, P> const & v);
+		template<typename U>
+		GLM_FUNC_DECL vec & operator%=(vec<3, U, P> const & v);
+		template<typename U>
+		GLM_FUNC_DECL vec & operator&=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL vec & operator&=(vec<1, U, P> const & v);
+		template<typename U>
+		GLM_FUNC_DECL vec & operator&=(vec<3, U, P> const & v);
+		template<typename U>
+		GLM_FUNC_DECL vec & operator|=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL vec & operator|=(vec<1, U, P> const & v);
+		template<typename U>
+		GLM_FUNC_DECL vec & operator|=(vec<3, U, P> const & v);
+		template<typename U>
+		GLM_FUNC_DECL vec & operator^=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL vec & operator^=(vec<1, U, P> const & v);
+		template<typename U>
+		GLM_FUNC_DECL vec & operator^=(vec<3, U, P> const & v);
+		template<typename U>
+		GLM_FUNC_DECL vec & operator<<=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL vec & operator<<=(vec<1, U, P> const & v);
+		template<typename U>
+		GLM_FUNC_DECL vec & operator<<=(vec<3, U, P> const & v);
+		template<typename U>
+		GLM_FUNC_DECL vec & operator>>=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL vec & operator>>=(vec<1, U, P> const & v);
+		template<typename U>
+		GLM_FUNC_DECL vec & operator>>=(vec<3, U, P> const & v);
 	};
 
 	// -- Unary operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> operator+(tvec3<T, P> const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<3, T, P> operator+(vec<3, T, P> const & v);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> operator-(tvec3<T, P> const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<3, T, P> operator-(vec<3, T, P> const & v);
 
 	// -- Binary operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> operator+(tvec3<T, P> const & v, T scalar);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<3, T, P> operator+(vec<3, T, P> const & v, T scalar);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> operator+(tvec3<T, P> const & v, tvec1<T, P> const & scalar);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<3, T, P> operator+(vec<3, T, P> const & v, vec<1, T, P> const & scalar);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> operator+(T scalar, tvec3<T, P> const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<3, T, P> operator+(T scalar, vec<3, T, P> const & v);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> operator+(tvec1<T, P> const & v1, tvec3<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<3, T, P> operator+(vec<1, T, P> const & v1, vec<3, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> operator+(tvec3<T, P> const & v1, tvec3<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<3, T, P> operator+(vec<3, T, P> const & v1, vec<3, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> operator-(tvec3<T, P> const & v, T scalar);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<3, T, P> operator-(vec<3, T, P> const & v, T scalar);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> operator-(tvec3<T, P> const & v1, tvec1<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<3, T, P> operator-(vec<3, T, P> const & v1, vec<1, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> operator-(T scalar, tvec3<T, P> const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<3, T, P> operator-(T scalar, vec<3, T, P> const & v);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> operator-(tvec1<T, P> const & v1, tvec3<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<3, T, P> operator-(vec<1, T, P> const & v1, vec<3, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> operator-(tvec3<T, P> const & v1, tvec3<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<3, T, P> operator-(vec<3, T, P> const & v1, vec<3, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> operator*(tvec3<T, P> const & v, T scalar);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<3, T, P> operator*(vec<3, T, P> const & v, T scalar);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> operator*(tvec3<T, P> const & v1, tvec1<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<3, T, P> operator*(vec<3, T, P> const & v1, vec<1, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> operator*(T scalar, tvec3<T, P> const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<3, T, P> operator*(T scalar, vec<3, T, P> const & v);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> operator*(tvec1<T, P> const & v1, tvec3<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<3, T, P> operator*(vec<1, T, P> const & v1, vec<3, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> operator*(tvec3<T, P> const & v1, tvec3<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<3, T, P> operator*(vec<3, T, P> const & v1, vec<3, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> operator/(tvec3<T, P> const & v, T scalar);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<3, T, P> operator/(vec<3, T, P> const & v, T scalar);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> operator/(tvec3<T, P> const & v1, tvec1<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<3, T, P> operator/(vec<3, T, P> const & v1, vec<1, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> operator/(T scalar, tvec3<T, P> const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<3, T, P> operator/(T scalar, vec<3, T, P> const & v);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> operator/(tvec1<T, P> const & v1, tvec3<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<3, T, P> operator/(vec<1, T, P> const & v1, vec<3, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> operator/(tvec3<T, P> const & v1, tvec3<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<3, T, P> operator/(vec<3, T, P> const & v1, vec<3, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> operator%(tvec3<T, P> const & v, T scalar);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<3, T, P> operator%(vec<3, T, P> const & v, T scalar);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> operator%(tvec3<T, P> const & v1, tvec1<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<3, T, P> operator%(vec<3, T, P> const & v1, vec<1, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> operator%(T const & scalar, tvec3<T, P> const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<3, T, P> operator%(T const & scalar, vec<3, T, P> const & v);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> operator%(tvec1<T, P> const & v1, tvec3<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<3, T, P> operator%(vec<1, T, P> const & v1, vec<3, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> operator%(tvec3<T, P> const & v1, tvec3<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<3, T, P> operator%(vec<3, T, P> const & v1, vec<3, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> operator&(tvec3<T, P> const & v1, T scalar);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<3, T, P> operator&(vec<3, T, P> const & v1, T scalar);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> operator&(tvec3<T, P> const & v1, tvec1<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<3, T, P> operator&(vec<3, T, P> const & v1, vec<1, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> operator&(T scalar, tvec3<T, P> const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<3, T, P> operator&(T scalar, vec<3, T, P> const & v);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> operator&(tvec1<T, P> const & v1, tvec3<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<3, T, P> operator&(vec<1, T, P> const & v1, vec<3, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> operator&(tvec3<T, P> const & v1, tvec3<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<3, T, P> operator&(vec<3, T, P> const & v1, vec<3, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> operator|(tvec3<T, P> const & v, T scalar);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<3, T, P> operator|(vec<3, T, P> const & v, T scalar);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> operator|(tvec3<T, P> const & v1, tvec1<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<3, T, P> operator|(vec<3, T, P> const & v1, vec<1, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> operator|(T scalar, tvec3<T, P> const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<3, T, P> operator|(T scalar, vec<3, T, P> const & v);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> operator|(tvec1<T, P> const & v1, tvec3<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<3, T, P> operator|(vec<1, T, P> const & v1, vec<3, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> operator|(tvec3<T, P> const & v1, tvec3<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<3, T, P> operator|(vec<3, T, P> const & v1, vec<3, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> operator^(tvec3<T, P> const & v, T scalar);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<3, T, P> operator^(vec<3, T, P> const & v, T scalar);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> operator^(tvec3<T, P> const & v1, tvec1<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<3, T, P> operator^(vec<3, T, P> const & v1, vec<1, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> operator^(T scalar, tvec3<T, P> const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<3, T, P> operator^(T scalar, vec<3, T, P> const & v);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> operator^(tvec1<T, P> const & v1, tvec3<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<3, T, P> operator^(vec<1, T, P> const & v1, vec<3, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> operator^(tvec3<T, P> const & v1, tvec3<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<3, T, P> operator^(vec<3, T, P> const & v1, vec<3, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> operator<<(tvec3<T, P> const & v, T scalar);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<3, T, P> operator<<(vec<3, T, P> const & v, T scalar);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> operator<<(tvec3<T, P> const & v1, tvec1<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<3, T, P> operator<<(vec<3, T, P> const & v1, vec<1, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> operator<<(T scalar, tvec3<T, P> const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<3, T, P> operator<<(T scalar, vec<3, T, P> const & v);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> operator<<(tvec1<T, P> const & v1, tvec3<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<3, T, P> operator<<(vec<1, T, P> const & v1, vec<3, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> operator<<(tvec3<T, P> const & v1, tvec3<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<3, T, P> operator<<(vec<3, T, P> const & v1, vec<3, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> operator>>(tvec3<T, P> const & v, T scalar);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<3, T, P> operator>>(vec<3, T, P> const & v, T scalar);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> operator>>(tvec3<T, P> const & v1, tvec1<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<3, T, P> operator>>(vec<3, T, P> const & v1, vec<1, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> operator>>(T scalar, tvec3<T, P> const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<3, T, P> operator>>(T scalar, vec<3, T, P> const & v);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> operator>>(tvec1<T, P> const & v1, tvec3<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<3, T, P> operator>>(vec<1, T, P> const & v1, vec<3, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> operator>>(tvec3<T, P> const & v1, tvec3<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<3, T, P> operator>>(vec<3, T, P> const & v1, vec<3, T, P> const & v2);
 
-	template <typename T, precision P> 
-	GLM_FUNC_DECL tvec3<T, P> operator~(tvec3<T, P> const & v);
+	template<typename T, precision P> 
+	GLM_FUNC_DECL vec<3, T, P> operator~(vec<3, T, P> const & v);
 
 	// -- Boolean operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL bool operator==(tvec3<T, P> const & v1, tvec3<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL bool operator==(vec<3, T, P> const & v1, vec<3, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL bool operator!=(tvec3<T, P> const & v1, tvec3<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL bool operator!=(vec<3, T, P> const & v1, vec<3, T, P> const & v2);
 
-	template <precision P>
-	GLM_FUNC_DECL tvec3<bool, P> operator&&(tvec3<bool, P> const & v1, tvec3<bool, P> const & v2);
+	template<precision P>
+	GLM_FUNC_DECL vec<3, bool, P> operator&&(vec<3, bool, P> const & v1, vec<3, bool, P> const & v2);
 
-	template <precision P>
-	GLM_FUNC_DECL tvec3<bool, P> operator||(tvec3<bool, P> const & v1, tvec3<bool, P> const & v2);
+	template<precision P>
+	GLM_FUNC_DECL vec<3, bool, P> operator||(vec<3, bool, P> const & v1, vec<3, bool, P> const & v2);
 }//namespace glm
 
 #ifndef GLM_EXTERNAL_TEMPLATE
diff --git a/glm/detail/type_vec3.inl b/glm/detail/type_vec3.inl
index 664554eb..55b17efe 100644
--- a/glm/detail/type_vec3.inl
+++ b/glm/detail/type_vec3.inl
@@ -6,8 +6,8 @@ namespace glm
 	// -- Implicit basic constructors --
 
 #	if !GLM_HAS_DEFAULTED_FUNCTIONS || !defined(GLM_FORCE_NO_CTOR_INIT)
-		template <typename T, precision P>
-		GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec3<T, P>::tvec3()
+		template<typename T, precision P>
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, P>::vec()
 #			ifndef GLM_FORCE_NO_CTOR_INIT 
 				: x(0), y(0), z(0)
 #			endif
@@ -15,47 +15,47 @@ namespace glm
 #	endif//!GLM_HAS_DEFAULTED_FUNCTIONS
 
 #	if !GLM_HAS_DEFAULTED_FUNCTIONS
-		template <typename T, precision P>
-		GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec3<T, P>::tvec3(tvec3<T, P> const & v)
+		template<typename T, precision P>
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, P>::vec(vec<3, T, P> const & v)
 			: x(v.x), y(v.y), z(v.z)
 		{}
 #	endif//!GLM_HAS_DEFAULTED_FUNCTIONS
 
-	template <typename T, precision P>
-	template <precision Q>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec3<T, P>::tvec3(tvec3<T, Q> const & v)
+	template<typename T, precision P>
+	template<precision Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, P>::vec(vec<3, T, Q> const & v)
 		: x(v.x), y(v.y), z(v.z)
 	{}
 
 	// -- Explicit basic constructors --
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR tvec3<T, P>::tvec3(ctor)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<3, T, P>::vec(ctor)
 	{}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec3<T, P>::tvec3(T scalar)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, P>::vec(T scalar)
 		: x(scalar), y(scalar), z(scalar)
 	{}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec3<T, P>::tvec3(T a, T b, T c)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, P>::vec(T a, T b, T c)
 		: x(a), y(b), z(c)
 	{}
 
 	// -- Conversion scalar constructors --
 
-	template <typename T, precision P>
-	template <typename A, typename B, typename C>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec3<T, P>::tvec3(A a, B b, C c) :
+	template<typename T, precision P>
+	template<typename A, typename B, typename C>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, P>::vec(A a, B b, C c) :
 		x(static_cast<T>(a)),
 		y(static_cast<T>(b)),
 		z(static_cast<T>(c))
 	{}
 
-	template <typename T, precision P>
-	template <typename A, typename B, typename C>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec3<T, P>::tvec3(tvec1<A, P> const & a, tvec1<B, P> const & b, tvec1<C, P> const & c) :
+	template<typename T, precision P>
+	template<typename A, typename B, typename C>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, P>::vec(vec<1, A, P> const & a, vec<1, B, P> const & b, vec<1, C, P> const & c) :
 		x(static_cast<T>(a)),
 		y(static_cast<T>(b)),
 		z(static_cast<T>(c))
@@ -63,49 +63,49 @@ namespace glm
 
 	// -- Conversion vector constructors --
 
-	template <typename T, precision P>
-	template <typename A, typename B, precision Q>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec3<T, P>::tvec3(tvec2<A, Q> const & a, B b) :
+	template<typename T, precision P>
+	template<typename A, typename B, precision Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, P>::vec(vec<2, A, Q> const & a, B b) :
 		x(static_cast<T>(a.x)),
 		y(static_cast<T>(a.y)),
 		z(static_cast<T>(b))
 	{}
 
-	template <typename T, precision P>
-	template <typename A, typename B, precision Q>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec3<T, P>::tvec3(tvec2<A, Q> const & a, tvec1<B, Q> const & b) :
+	template<typename T, precision P>
+	template<typename A, typename B, precision Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, P>::vec(vec<2, A, Q> const & a, vec<1, B, Q> const & b) :
 		x(static_cast<T>(a.x)),
 		y(static_cast<T>(a.y)),
 		z(static_cast<T>(b.x))
 	{}
 
-	template <typename T, precision P>
-	template <typename A, typename B, precision Q>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec3<T, P>::tvec3(A a, tvec2<B, Q> const & b) :
+	template<typename T, precision P>
+	template<typename A, typename B, precision Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, P>::vec(A a, vec<2, B, Q> const & b) :
 		x(static_cast<T>(a)),
 		y(static_cast<T>(b.x)),
 		z(static_cast<T>(b.y))
 	{}
 
-	template <typename T, precision P>
-	template <typename A, typename B, precision Q>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec3<T, P>::tvec3(tvec1<A, Q> const & a, tvec2<B, Q> const & b) :
+	template<typename T, precision P>
+	template<typename A, typename B, precision Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, P>::vec(vec<1, A, Q> const & a, vec<2, B, Q> const & b) :
 		x(static_cast<T>(a.x)),
 		y(static_cast<T>(b.x)),
 		z(static_cast<T>(b.y))
 	{}
 
-	template <typename T, precision P>
-	template <typename U, precision Q>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec3<T, P>::tvec3(tvec3<U, Q> const & v) :
+	template<typename T, precision P>
+	template<typename U, precision Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, P>::vec(vec<3, U, Q> const & v) :
 		x(static_cast<T>(v.x)),
 		y(static_cast<T>(v.y)),
 		z(static_cast<T>(v.z))
 	{}
 
-	template <typename T, precision P>
-	template <typename U, precision Q>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec3<T, P>::tvec3(tvec4<U, Q> const & v) :
+	template<typename T, precision P>
+	template<typename U, precision Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, P>::vec(vec<4, U, Q> const & v) :
 		x(static_cast<T>(v.x)),
 		y(static_cast<T>(v.y)),
 		z(static_cast<T>(v.z))
@@ -113,15 +113,15 @@ namespace glm
 
 	// -- Component accesses --
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER T & tvec3<T, P>::operator[](typename tvec3<T, P>::length_type i)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER T & vec<3, T, P>::operator[](typename vec<3, T, P>::length_type i)
 	{
 		assert(i >= 0 && i < this->length());
 		return (&x)[i];
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER T const & tvec3<T, P>::operator[](typename tvec3<T, P>::length_type i) const
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER T const & vec<3, T, P>::operator[](typename vec<3, T, P>::length_type i) const
 	{
 		assert(i >= 0 && i < this->length());
 		return (&x)[i];
@@ -130,8 +130,8 @@ namespace glm
 	// -- Unary arithmetic operators --
 
 #	if !GLM_HAS_DEFAULTED_FUNCTIONS
-		template <typename T, precision P>
-		GLM_FUNC_QUALIFIER tvec3<T, P>& tvec3<T, P>::operator=(tvec3<T, P> const & v)
+		template<typename T, precision P>
+		GLM_FUNC_QUALIFIER vec<3, T, P>& vec<3, T, P>::operator=(vec<3, T, P> const & v)
 		{
 			this->x = v.x;
 			this->y = v.y;
@@ -140,9 +140,9 @@ namespace glm
 		}
 #	endif//!GLM_HAS_DEFAULTED_FUNCTIONS
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tvec3<T, P>& tvec3<T, P>::operator=(tvec3<U, P> const & v)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<3, T, P>& vec<3, T, P>::operator=(vec<3, U, P> const & v)
 	{
 		this->x = static_cast<T>(v.x);
 		this->y = static_cast<T>(v.y);
@@ -150,9 +150,9 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tvec3<T, P> & tvec3<T, P>::operator+=(U scalar)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator+=(U scalar)
 	{
 		this->x += static_cast<T>(scalar);
 		this->y += static_cast<T>(scalar);
@@ -160,9 +160,9 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tvec3<T, P> & tvec3<T, P>::operator+=(tvec1<U, P> const & v)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator+=(vec<1, U, P> const & v)
 	{
 		this->x += static_cast<T>(v.x);
 		this->y += static_cast<T>(v.x);
@@ -170,9 +170,9 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tvec3<T, P> & tvec3<T, P>::operator+=(tvec3<U, P> const & v)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator+=(vec<3, U, P> const & v)
 	{
 		this->x += static_cast<T>(v.x);
 		this->y += static_cast<T>(v.y);
@@ -180,9 +180,9 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tvec3<T, P> & tvec3<T, P>::operator-=(U scalar)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator-=(U scalar)
 	{
 		this->x -= static_cast<T>(scalar);
 		this->y -= static_cast<T>(scalar);
@@ -190,9 +190,9 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tvec3<T, P> & tvec3<T, P>::operator-=(tvec1<U, P> const & v)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator-=(vec<1, U, P> const & v)
 	{
 		this->x -= static_cast<T>(v.x);
 		this->y -= static_cast<T>(v.x);
@@ -200,9 +200,9 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tvec3<T, P> & tvec3<T, P>::operator-=(tvec3<U, P> const & v)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator-=(vec<3, U, P> const & v)
 	{
 		this->x -= static_cast<T>(v.x);
 		this->y -= static_cast<T>(v.y);
@@ -210,9 +210,9 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tvec3<T, P> & tvec3<T, P>::operator*=(U scalar)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator*=(U scalar)
 	{
 		this->x *= static_cast<T>(scalar);
 		this->y *= static_cast<T>(scalar);
@@ -220,9 +220,9 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tvec3<T, P> & tvec3<T, P>::operator*=(tvec1<U, P> const & v)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator*=(vec<1, U, P> const & v)
 	{
 		this->x *= static_cast<T>(v.x);
 		this->y *= static_cast<T>(v.x);
@@ -230,9 +230,9 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tvec3<T, P> & tvec3<T, P>::operator*=(tvec3<U, P> const & v)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator*=(vec<3, U, P> const & v)
 	{
 		this->x *= static_cast<T>(v.x);
 		this->y *= static_cast<T>(v.y);
@@ -240,9 +240,9 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tvec3<T, P> & tvec3<T, P>::operator/=(U v)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator/=(U v)
 	{
 		this->x /= static_cast<T>(v);
 		this->y /= static_cast<T>(v);
@@ -250,9 +250,9 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tvec3<T, P> & tvec3<T, P>::operator/=(tvec1<U, P> const & v)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator/=(vec<1, U, P> const & v)
 	{
 		this->x /= static_cast<T>(v.x);
 		this->y /= static_cast<T>(v.x);
@@ -260,9 +260,9 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tvec3<T, P> & tvec3<T, P>::operator/=(tvec3<U, P> const & v)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator/=(vec<3, U, P> const & v)
 	{
 		this->x /= static_cast<T>(v.x);
 		this->y /= static_cast<T>(v.y);
@@ -272,8 +272,8 @@ namespace glm
 
 	// -- Increment and decrement operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> & tvec3<T, P>::operator++()
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator++()
 	{
 		++this->x;
 		++this->y;
@@ -281,8 +281,8 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> & tvec3<T, P>::operator--()
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator--()
 	{
 		--this->x;
 		--this->y;
@@ -290,27 +290,27 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tvec3<T, P> tvec3<T, P>::operator++(int)
+	template<typename T, precision P> 
+	GLM_FUNC_QUALIFIER vec<3, T, P> vec<3, T, P>::operator++(int)
 	{
-		tvec3<T, P> Result(*this);
+		vec<3, T, P> Result(*this);
 		++*this;
 		return Result;
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tvec3<T, P> tvec3<T, P>::operator--(int)
+	template<typename T, precision P> 
+	GLM_FUNC_QUALIFIER vec<3, T, P> vec<3, T, P>::operator--(int)
 	{
-		tvec3<T, P> Result(*this);
+		vec<3, T, P> Result(*this);
 		--*this;
 		return Result;
 	}
 
 	// -- Unary bit operators --
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tvec3<T, P> & tvec3<T, P>::operator%=(U scalar)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator%=(U scalar)
 	{
 		this->x %= scalar;
 		this->y %= scalar;
@@ -318,9 +318,9 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tvec3<T, P> & tvec3<T, P>::operator%=(tvec1<U, P> const & v)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator%=(vec<1, U, P> const & v)
 	{
 		this->x %= v.x;
 		this->y %= v.x;
@@ -328,9 +328,9 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tvec3<T, P> & tvec3<T, P>::operator%=(tvec3<U, P> const & v)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator%=(vec<3, U, P> const & v)
 	{
 		this->x %= v.x;
 		this->y %= v.y;
@@ -338,9 +338,9 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tvec3<T, P> & tvec3<T, P>::operator&=(U scalar)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator&=(U scalar)
 	{
 		this->x &= scalar;
 		this->y &= scalar;
@@ -348,9 +348,9 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tvec3<T, P> & tvec3<T, P>::operator&=(tvec1<U, P> const & v)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator&=(vec<1, U, P> const & v)
 	{
 		this->x &= v.x;
 		this->y &= v.x;
@@ -358,9 +358,9 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tvec3<T, P> & tvec3<T, P>::operator&=(tvec3<U, P> const & v)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator&=(vec<3, U, P> const & v)
 	{
 		this->x &= v.x;
 		this->y &= v.y;
@@ -368,9 +368,9 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tvec3<T, P> & tvec3<T, P>::operator|=(U scalar)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator|=(U scalar)
 	{
 		this->x |= scalar;
 		this->y |= scalar;
@@ -378,9 +378,9 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<T, P> & tvec3<T, P>::operator|=(tvec1<U, P> const & v)
+	template<typename T, precision P>
+	template<typename U> 
+	GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator|=(vec<1, U, P> const & v)
 	{
 		this->x |= v.x;
 		this->y |= v.x;
@@ -388,9 +388,9 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<T, P> & tvec3<T, P>::operator|=(tvec3<U, P> const & v)
+	template<typename T, precision P>
+	template<typename U> 
+	GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator|=(vec<3, U, P> const & v)
 	{
 		this->x |= v.x;
 		this->y |= v.y;
@@ -398,9 +398,9 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<T, P> & tvec3<T, P>::operator^=(U scalar)
+	template<typename T, precision P>
+	template<typename U> 
+	GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator^=(U scalar)
 	{
 		this->x ^= scalar;
 		this->y ^= scalar;
@@ -408,9 +408,9 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<T, P> & tvec3<T, P>::operator^=(tvec1<U, P> const & v)
+	template<typename T, precision P>
+	template<typename U> 
+	GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator^=(vec<1, U, P> const & v)
 	{
 		this->x ^= v.x;
 		this->y ^= v.x;
@@ -418,9 +418,9 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<T, P> & tvec3<T, P>::operator^=(tvec3<U, P> const & v)
+	template<typename T, precision P>
+	template<typename U> 
+	GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator^=(vec<3, U, P> const & v)
 	{
 		this->x ^= v.x;
 		this->y ^= v.y;
@@ -428,9 +428,9 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<T, P> & tvec3<T, P>::operator<<=(U scalar)
+	template<typename T, precision P>
+	template<typename U> 
+	GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator<<=(U scalar)
 	{
 		this->x <<= scalar;
 		this->y <<= scalar;
@@ -438,9 +438,9 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<T, P> & tvec3<T, P>::operator<<=(tvec1<U, P> const & v)
+	template<typename T, precision P>
+	template<typename U> 
+	GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator<<=(vec<1, U, P> const & v)
 	{
 		this->x <<= static_cast<T>(v.x);
 		this->y <<= static_cast<T>(v.x);
@@ -448,9 +448,9 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<T, P> & tvec3<T, P>::operator<<=(tvec3<U, P> const & v)
+	template<typename T, precision P>
+	template<typename U> 
+	GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator<<=(vec<3, U, P> const & v)
 	{
 		this->x <<= static_cast<T>(v.x);
 		this->y <<= static_cast<T>(v.y);
@@ -458,9 +458,9 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<T, P> & tvec3<T, P>::operator>>=(U scalar)
+	template<typename T, precision P>
+	template<typename U> 
+	GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator>>=(U scalar)
 	{
 		this->x >>= static_cast<T>(scalar);
 		this->y >>= static_cast<T>(scalar);
@@ -468,9 +468,9 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<T, P> & tvec3<T, P>::operator>>=(tvec1<U, P> const & v)
+	template<typename T, precision P>
+	template<typename U> 
+	GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator>>=(vec<1, U, P> const & v)
 	{
 		this->x >>= static_cast<T>(v.x);
 		this->y >>= static_cast<T>(v.x);
@@ -478,9 +478,9 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<T, P> & tvec3<T, P>::operator>>=(tvec3<U, P> const & v)
+	template<typename T, precision P>
+	template<typename U> 
+	GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator>>=(vec<3, U, P> const & v)
 	{
 		this->x >>= static_cast<T>(v.x);
 		this->y >>= static_cast<T>(v.y);
@@ -490,16 +490,16 @@ namespace glm
 
 	// -- Unary arithmetic operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> operator+(tvec3<T, P> const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> operator+(vec<3, T, P> const & v)
 	{
 		return v;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> operator-(tvec3<T, P> const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> operator-(vec<3, T, P> const & v)
 	{
-		return tvec3<T, P>(
+		return vec<3, T, P>(
 			-v.x, 
 			-v.y, 
 			-v.z);
@@ -507,181 +507,181 @@ namespace glm
 
 	// -- Binary arithmetic operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> operator+(tvec3<T, P> const & v, T scalar)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> operator+(vec<3, T, P> const & v, T scalar)
 	{
-		return tvec3<T, P>(
+		return vec<3, T, P>(
 			v.x + scalar,
 			v.y + scalar,
 			v.z + scalar);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> operator+(tvec3<T, P> const & v, tvec1<T, P> const & scalar)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> operator+(vec<3, T, P> const & v, vec<1, T, P> const & scalar)
 	{
-		return tvec3<T, P>(
+		return vec<3, T, P>(
 			v.x + scalar.x,
 			v.y + scalar.x,
 			v.z + scalar.x);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> operator+(T scalar, tvec3<T, P> const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> operator+(T scalar, vec<3, T, P> const & v)
 	{
-		return tvec3<T, P>(
+		return vec<3, T, P>(
 			scalar + v.x,
 			scalar + v.y,
 			scalar + v.z);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> operator+(tvec1<T, P> const & scalar, tvec3<T, P> const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> operator+(vec<1, T, P> const & scalar, vec<3, T, P> const & v)
 	{
-		return tvec3<T, P>(
+		return vec<3, T, P>(
 			scalar.x + v.x,
 			scalar.x + v.y,
 			scalar.x + v.z);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> operator+(tvec3<T, P> const & v1, tvec3<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> operator+(vec<3, T, P> const & v1, vec<3, T, P> const & v2)
 	{
-		return tvec3<T, P>(
+		return vec<3, T, P>(
 			v1.x + v2.x,
 			v1.y + v2.y,
 			v1.z + v2.z);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> operator-(tvec3<T, P> const & v, T scalar)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> operator-(vec<3, T, P> const & v, T scalar)
 	{
-		return tvec3<T, P>(
+		return vec<3, T, P>(
 			v.x - scalar,
 			v.y - scalar,
 			v.z - scalar);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> operator-(tvec3<T, P> const & v, tvec1<T, P> const & scalar)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> operator-(vec<3, T, P> const & v, vec<1, T, P> const & scalar)
 	{
-		return tvec3<T, P>(
+		return vec<3, T, P>(
 			v.x - scalar.x,
 			v.y - scalar.x,
 			v.z - scalar.x);
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tvec3<T, P> operator-(T scalar, tvec3<T, P> const & v)
+	template<typename T, precision P> 
+	GLM_FUNC_QUALIFIER vec<3, T, P> operator-(T scalar, vec<3, T, P> const & v)
 	{
-		return tvec3<T, P>(
+		return vec<3, T, P>(
 			scalar - v.x,
 			scalar - v.y,
 			scalar - v.z);
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tvec3<T, P> operator-(tvec1<T, P> const & scalar, tvec3<T, P> const & v)
+	template<typename T, precision P> 
+	GLM_FUNC_QUALIFIER vec<3, T, P> operator-(vec<1, T, P> const & scalar, vec<3, T, P> const & v)
 	{
-		return tvec3<T, P>(
+		return vec<3, T, P>(
 			scalar.x - v.x,
 			scalar.x - v.y,
 			scalar.x - v.z);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> operator-(tvec3<T, P> const & v1, tvec3<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> operator-(vec<3, T, P> const & v1, vec<3, T, P> const & v2)
 	{
-		return tvec3<T, P>(
+		return vec<3, T, P>(
 			v1.x - v2.x,
 			v1.y - v2.y,
 			v1.z - v2.z);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> operator*(tvec3<T, P> const & v, T scalar)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> operator*(vec<3, T, P> const & v, T scalar)
 	{
-		return tvec3<T, P>(
+		return vec<3, T, P>(
 			v.x * scalar,
 			v.y * scalar,
 			v.z * scalar);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> operator*(tvec3<T, P> const & v, tvec1<T, P> const & scalar)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> operator*(vec<3, T, P> const & v, vec<1, T, P> const & scalar)
 	{
-		return tvec3<T, P>(
+		return vec<3, T, P>(
 			v.x * scalar.x,
 			v.y * scalar.x,
 			v.z * scalar.x);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> operator*(T scalar, tvec3<T, P> const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> operator*(T scalar, vec<3, T, P> const & v)
 	{
-		return tvec3<T, P>(
+		return vec<3, T, P>(
 			scalar * v.x,
 			scalar * v.y,
 			scalar * v.z);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> operator*(tvec1<T, P> const & scalar, tvec3<T, P> const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> operator*(vec<1, T, P> const & scalar, vec<3, T, P> const & v)
 	{
-		return tvec3<T, P>(
+		return vec<3, T, P>(
 			scalar.x * v.x,
 			scalar.x * v.y,
 			scalar.x * v.z);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> operator*(tvec3<T, P> const & v1, tvec3<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> operator*(vec<3, T, P> const & v1, vec<3, T, P> const & v2)
 	{
-		return tvec3<T, P>(
+		return vec<3, T, P>(
 			v1.x * v2.x,
 			v1.y * v2.y,
 			v1.z * v2.z);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> operator/(tvec3<T, P> const & v, T scalar)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> operator/(vec<3, T, P> const & v, T scalar)
 	{
-		return tvec3<T, P>(
+		return vec<3, T, P>(
 			v.x / scalar,
 			v.y / scalar,
 			v.z / scalar);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> operator/(tvec3<T, P> const & v, tvec1<T, P> const & scalar)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> operator/(vec<3, T, P> const & v, vec<1, T, P> const & scalar)
 	{
-		return tvec3<T, P>(
+		return vec<3, T, P>(
 			v.x / scalar.x,
 			v.y / scalar.x,
 			v.z / scalar.x);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> operator/(T scalar, tvec3<T, P> const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> operator/(T scalar, vec<3, T, P> const & v)
 	{
-		return tvec3<T, P>(
+		return vec<3, T, P>(
 			scalar / v.x,
 			scalar / v.y,
 			scalar / v.z);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> operator/(tvec1<T, P> const & scalar, tvec3<T, P> const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> operator/(vec<1, T, P> const & scalar, vec<3, T, P> const & v)
 	{
-		return tvec3<T, P>(
+		return vec<3, T, P>(
 			scalar.x / v.x,
 			scalar.x / v.y,
 			scalar.x / v.z);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> operator/(tvec3<T, P> const & v1, tvec3<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> operator/(vec<3, T, P> const & v1, vec<3, T, P> const & v2)
 	{
-		return tvec3<T, P>(
+		return vec<3, T, P>(
 			v1.x / v2.x,
 			v1.y / v2.y,
 			v1.z / v2.z);
@@ -689,280 +689,280 @@ namespace glm
 
 	// -- Binary bit operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> operator%(tvec3<T, P> const & v, T scalar)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> operator%(vec<3, T, P> const & v, T scalar)
 	{
-		return tvec3<T, P>(
+		return vec<3, T, P>(
 			v.x % scalar,
 			v.y % scalar,
 			v.z % scalar);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> operator%(tvec3<T, P> const & v, tvec1<T, P> const & scalar)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> operator%(vec<3, T, P> const & v, vec<1, T, P> const & scalar)
 	{
-		return tvec3<T, P>(
+		return vec<3, T, P>(
 			v.x % scalar.x,
 			v.y % scalar.x,
 			v.z % scalar.x);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> operator%(T scalar, tvec3<T, P> const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> operator%(T scalar, vec<3, T, P> const & v)
 	{
-		return tvec3<T, P>(
+		return vec<3, T, P>(
 			scalar % v.x,
 			scalar % v.y,
 			scalar % v.z);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> operator%(tvec1<T, P> const & scalar, tvec3<T, P> const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> operator%(vec<1, T, P> const & scalar, vec<3, T, P> const & v)
 	{
-		return tvec3<T, P>(
+		return vec<3, T, P>(
 			scalar.x % v.x,
 			scalar.x % v.y,
 			scalar.x % v.z);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> operator%(tvec3<T, P> const & v1, tvec3<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> operator%(vec<3, T, P> const & v1, vec<3, T, P> const & v2)
 	{
-		return tvec3<T, P>(
+		return vec<3, T, P>(
 			v1.x % v2.x,
 			v1.y % v2.y,
 			v1.z % v2.z);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> operator&(tvec3<T, P> const & v, T scalar)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> operator&(vec<3, T, P> const & v, T scalar)
 	{
-		return tvec3<T, P>(
+		return vec<3, T, P>(
 			v.x & scalar,
 			v.y & scalar,
 			v.z & scalar);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> operator&(tvec3<T, P> const & v, tvec1<T, P> const & scalar)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> operator&(vec<3, T, P> const & v, vec<1, T, P> const & scalar)
 	{
-		return tvec3<T, P>(
+		return vec<3, T, P>(
 			v.x & scalar.x,
 			v.y & scalar.x,
 			v.z & scalar.x);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> operator&(T scalar, tvec3<T, P> const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> operator&(T scalar, vec<3, T, P> const & v)
 	{
-		return tvec3<T, P>(
+		return vec<3, T, P>(
 			scalar & v.x,
 			scalar & v.y,
 			scalar & v.z);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> operator&(tvec1<T, P> const & scalar, tvec3<T, P> const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> operator&(vec<1, T, P> const & scalar, vec<3, T, P> const & v)
 	{
-		return tvec3<T, P>(
+		return vec<3, T, P>(
 			scalar.x & v.x,
 			scalar.x & v.y,
 			scalar.x & v.z);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> operator&(tvec3<T, P> const & v1, tvec3<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> operator&(vec<3, T, P> const & v1, vec<3, T, P> const & v2)
 	{
-		return tvec3<T, P>(
+		return vec<3, T, P>(
 			v1.x & v2.x,
 			v1.y & v2.y,
 			v1.z & v2.z);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> operator|(tvec3<T, P> const & v, T scalar)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> operator|(vec<3, T, P> const & v, T scalar)
 	{
-		return tvec3<T, P>(
+		return vec<3, T, P>(
 			v.x | scalar,
 			v.y | scalar,
 			v.z | scalar);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> operator|(tvec3<T, P> const & v, tvec1<T, P> const & scalar)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> operator|(vec<3, T, P> const & v, vec<1, T, P> const & scalar)
 	{
-		return tvec3<T, P>(
+		return vec<3, T, P>(
 			v.x | scalar.x,
 			v.y | scalar.x,
 			v.z | scalar.x);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> operator|(T scalar, tvec3<T, P> const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> operator|(T scalar, vec<3, T, P> const & v)
 	{
-		return tvec3<T, P>(
+		return vec<3, T, P>(
 			scalar | v.x,
 			scalar | v.y,
 			scalar | v.z);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> operator|(tvec1<T, P> const & scalar, tvec3<T, P> const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> operator|(vec<1, T, P> const & scalar, vec<3, T, P> const & v)
 	{
-		return tvec3<T, P>(
+		return vec<3, T, P>(
 			scalar.x | v.x,
 			scalar.x | v.y,
 			scalar.x | v.z);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> operator|(tvec3<T, P> const & v1, tvec3<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> operator|(vec<3, T, P> const & v1, vec<3, T, P> const & v2)
 	{
-		return tvec3<T, P>(
+		return vec<3, T, P>(
 			v1.x | v2.x,
 			v1.y | v2.y,
 			v1.z | v2.z);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> operator^(tvec3<T, P> const & v, T scalar)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> operator^(vec<3, T, P> const & v, T scalar)
 	{
-		return tvec3<T, P>(
+		return vec<3, T, P>(
 			v.x ^ scalar,
 			v.y ^ scalar,
 			v.z ^ scalar);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> operator^(tvec3<T, P> const & v, tvec1<T, P> const & scalar)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> operator^(vec<3, T, P> const & v, vec<1, T, P> const & scalar)
 	{
-		return tvec3<T, P>(
+		return vec<3, T, P>(
 			v.x ^ scalar.x,
 			v.y ^ scalar.x,
 			v.z ^ scalar.x);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> operator^(T scalar, tvec3<T, P> const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> operator^(T scalar, vec<3, T, P> const & v)
 	{
-		return tvec3<T, P>(
+		return vec<3, T, P>(
 			scalar ^ v.x,
 			scalar ^ v.y,
 			scalar ^ v.z);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> operator^(tvec1<T, P> const & scalar, tvec3<T, P> const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> operator^(vec<1, T, P> const & scalar, vec<3, T, P> const & v)
 	{
-		return tvec3<T, P>(
+		return vec<3, T, P>(
 			scalar.x ^ v.x,
 			scalar.x ^ v.y,
 			scalar.x ^ v.z);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> operator^(tvec3<T, P> const & v1, tvec3<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> operator^(vec<3, T, P> const & v1, vec<3, T, P> const & v2)
 	{
-		return tvec3<T, P>(
+		return vec<3, T, P>(
 			v1.x ^ v2.x,
 			v1.y ^ v2.y,
 			v1.z ^ v2.z);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> operator<<(tvec3<T, P> const & v, T scalar)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> operator<<(vec<3, T, P> const & v, T scalar)
 	{
-		return tvec3<T, P>(
+		return vec<3, T, P>(
 			v.x << scalar,
 			v.y << scalar,
 			v.z << scalar);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> operator<<(tvec3<T, P> const & v, tvec1<T, P> const & scalar)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> operator<<(vec<3, T, P> const & v, vec<1, T, P> const & scalar)
 	{
-		return tvec3<T, P>(
+		return vec<3, T, P>(
 			v.x << scalar.x,
 			v.y << scalar.x,
 			v.z << scalar.x);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> operator<<(T scalar, tvec3<T, P> const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> operator<<(T scalar, vec<3, T, P> const & v)
 	{
-		return tvec3<T, P>(
+		return vec<3, T, P>(
 			scalar << v.x,
 			scalar << v.y,
 			scalar << v.z);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> operator<<(tvec1<T, P> const & scalar, tvec3<T, P> const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> operator<<(vec<1, T, P> const & scalar, vec<3, T, P> const & v)
 	{
-		return tvec3<T, P>(
+		return vec<3, T, P>(
 			scalar.x << v.x,
 			scalar.x << v.y,
 			scalar.x << v.z);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> operator<<(tvec3<T, P> const & v1, tvec3<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> operator<<(vec<3, T, P> const & v1, vec<3, T, P> const & v2)
 	{
-		return tvec3<T, P>(
+		return vec<3, T, P>(
 			v1.x << v2.x,
 			v1.y << v2.y,
 			v1.z << v2.z);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> operator>>(tvec3<T, P> const & v, T scalar)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> operator>>(vec<3, T, P> const & v, T scalar)
 	{
-		return tvec3<T, P>(
+		return vec<3, T, P>(
 			v.x >> scalar,
 			v.y >> scalar,
 			v.z >> scalar);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> operator>>(tvec3<T, P> const & v, tvec1<T, P> const & scalar)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> operator>>(vec<3, T, P> const & v, vec<1, T, P> const & scalar)
 	{
-		return tvec3<T, P>(
+		return vec<3, T, P>(
 			v.x >> scalar.x,
 			v.y >> scalar.x,
 			v.z >> scalar.x);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> operator>>(T scalar, tvec3<T, P> const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> operator>>(T scalar, vec<3, T, P> const & v)
 	{
-		return tvec3<T, P>(
+		return vec<3, T, P>(
 			scalar >> v.x,
 			scalar >> v.y,
 			scalar >> v.z);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> operator>>(tvec1<T, P> const & scalar, tvec3<T, P> const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> operator>>(vec<1, T, P> const & scalar, vec<3, T, P> const & v)
 	{
-		return tvec3<T, P>(
+		return vec<3, T, P>(
 			scalar.x >> v.x,
 			scalar.x >> v.y,
 			scalar.x >> v.z);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> operator>>(tvec3<T, P> const & v1, tvec3<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> operator>>(vec<3, T, P> const & v1, vec<3, T, P> const & v2)
 	{
-		return tvec3<T, P>(
+		return vec<3, T, P>(
 			v1.x >> v2.x,
 			v1.y >> v2.y,
 			v1.z >> v2.z);
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tvec3<T, P> operator~(tvec3<T, P> const & v)
+	template<typename T, precision P> 
+	GLM_FUNC_QUALIFIER vec<3, T, P> operator~(vec<3, T, P> const & v)
 	{
-		return tvec3<T, P>(
+		return vec<3, T, P>(
 			~v.x,
 			~v.y,
 			~v.z);
@@ -970,27 +970,27 @@ namespace glm
 
 	// -- Boolean operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER bool operator==(tvec3<T, P> const & v1, tvec3<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER bool operator==(vec<3, T, P> const & v1, vec<3, T, P> const & v2)
 	{
 		return (v1.x == v2.x) && (v1.y == v2.y) && (v1.z == v2.z);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER bool operator!=(tvec3<T, P> const & v1, tvec3<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER bool operator!=(vec<3, T, P> const & v1, vec<3, T, P> const & v2)
 	{
 		return (v1.x != v2.x) || (v1.y != v2.y) || (v1.z != v2.z);
 	}
 
-	template <precision P>
-	GLM_FUNC_QUALIFIER tvec3<bool, P> operator&&(tvec3<bool, P> const & v1, tvec3<bool, P> const & v2)
+	template<precision P>
+	GLM_FUNC_QUALIFIER vec<3, bool, P> operator&&(vec<3, bool, P> const & v1, vec<3, bool, P> const & v2)
 	{
-		return tvec3<bool, P>(v1.x && v2.x, v1.y && v2.y, v1.z && v2.z);
+		return vec<3, bool, P>(v1.x && v2.x, v1.y && v2.y, v1.z && v2.z);
 	}
 
-	template <precision P>
-	GLM_FUNC_QUALIFIER tvec3<bool, P> operator||(tvec3<bool, P> const & v1, tvec3<bool, P> const & v2)
+	template<precision P>
+	GLM_FUNC_QUALIFIER vec<3, bool, P> operator||(vec<3, bool, P> const & v1, vec<3, bool, P> const & v2)
 	{
-		return tvec3<bool, P>(v1.x || v2.x, v1.y || v2.y, v1.z || v2.z);
+		return vec<3, bool, P>(v1.x || v2.x, v1.y || v2.y, v1.z || v2.z);
 	}
 }//namespace glm
diff --git a/glm/detail/type_vec4.hpp b/glm/detail/type_vec4.hpp
index c3923b4a..35a5ff4c 100644
--- a/glm/detail/type_vec4.hpp
+++ b/glm/detail/type_vec4.hpp
@@ -15,14 +15,14 @@
 
 namespace glm
 {
-	template <typename T, precision P = defaultp>
-	struct tvec4
+	template<typename T, precision P>
+	struct vec<4, T, P>
 	{
 		// -- Implementation detail --
 
 		typedef T value_type;
-		typedef tvec4<T, P> type;
-		typedef tvec4<bool, P> bool_type;
+		typedef vec<4, T, P> type;
+		typedef vec<4, bool, P> bool_type;
 
 		// -- Data --
 
@@ -36,7 +36,7 @@ namespace glm
 #				pragma clang diagnostic ignored "-Wgnu-anonymous-struct"
 #				pragma clang diagnostic ignored "-Wnested-anon-types"
 #			endif
-		
+
 			union
 			{
 				struct { T x, y, z, w;};
@@ -46,15 +46,15 @@ namespace glm
 				typename detail::storage<T, sizeof(T) * 4, detail::is_aligned<P>::value>::type data;
 
 #				if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED
-					_GLM_SWIZZLE4_2_MEMBERS(T, P, glm::tvec2, x, y, z, w)
-					_GLM_SWIZZLE4_2_MEMBERS(T, P, glm::tvec2, r, g, b, a)
-					_GLM_SWIZZLE4_2_MEMBERS(T, P, glm::tvec2, s, t, p, q)
-					_GLM_SWIZZLE4_3_MEMBERS(T, P, glm::tvec3, x, y, z, w)
-					_GLM_SWIZZLE4_3_MEMBERS(T, P, glm::tvec3, r, g, b, a)
-					_GLM_SWIZZLE4_3_MEMBERS(T, P, glm::tvec3, s, t, p, q)
-					_GLM_SWIZZLE4_4_MEMBERS(T, P, glm::tvec4, x, y, z, w)
-					_GLM_SWIZZLE4_4_MEMBERS(T, P, glm::tvec4, r, g, b, a)
-					_GLM_SWIZZLE4_4_MEMBERS(T, P, glm::tvec4, s, t, p, q)
+					_GLM_SWIZZLE4_2_MEMBERS(T, P, x, y, z, w)
+					_GLM_SWIZZLE4_2_MEMBERS(T, P, r, g, b, a)
+					_GLM_SWIZZLE4_2_MEMBERS(T, P, s, t, p, q)
+					_GLM_SWIZZLE4_3_MEMBERS(T, P, x, y, z, w)
+					_GLM_SWIZZLE4_3_MEMBERS(T, P, r, g, b, a)
+					_GLM_SWIZZLE4_3_MEMBERS(T, P, s, t, p, q)
+					_GLM_SWIZZLE4_4_MEMBERS(T, P, x, y, z, w)
+					_GLM_SWIZZLE4_4_MEMBERS(T, P, r, g, b, a)
+					_GLM_SWIZZLE4_4_MEMBERS(T, P, s, t, p, q)
 #				endif//GLM_SWIZZLE
 			};
 
@@ -71,7 +71,7 @@ namespace glm
 			union { T w, a, q; };
 
 #			if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED
-				GLM_SWIZZLE_GEN_VEC_FROM_VEC4(T, P, tvec4, tvec2, tvec3, tvec4)
+				GLM_SWIZZLE_GEN_VEC_FROM_VEC4(T, P)
 #			endif//GLM_SWIZZLE
 #		endif
 
@@ -86,364 +86,364 @@ namespace glm
 
 		// -- Implicit basic constructors --
 
-		GLM_FUNC_DECL GLM_CONSTEXPR_SIMD tvec4() GLM_DEFAULT_CTOR;
-		GLM_FUNC_DECL GLM_CONSTEXPR_SIMD tvec4(tvec4<T, P> const& v) GLM_DEFAULT;
-		template <precision Q>
-		GLM_FUNC_DECL GLM_CONSTEXPR_SIMD tvec4(tvec4<T, Q> const& v);
+		GLM_FUNC_DECL GLM_CONSTEXPR_SIMD vec() GLM_DEFAULT_CTOR;
+		GLM_FUNC_DECL GLM_CONSTEXPR_SIMD vec(vec<4, T, P> const& v) GLM_DEFAULT;
+		template<precision Q>
+		GLM_FUNC_DECL GLM_CONSTEXPR_SIMD vec(vec<4, T, Q> const& v);
 
 		// -- Explicit basic constructors --
 
-		GLM_FUNC_DECL GLM_CONSTEXPR_SIMD explicit tvec4(ctor);
-		GLM_FUNC_DECL GLM_CONSTEXPR_SIMD explicit tvec4(T scalar);
-		GLM_FUNC_DECL GLM_CONSTEXPR_SIMD tvec4(T a, T b, T c, T d);
+		GLM_FUNC_DECL GLM_CONSTEXPR_SIMD explicit vec(ctor);
+		GLM_FUNC_DECL GLM_CONSTEXPR_SIMD explicit vec(T scalar);
+		GLM_FUNC_DECL GLM_CONSTEXPR_SIMD vec(T a, T b, T c, T d);
 
 		// -- Conversion scalar constructors --
 
-		/// Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename A, typename B, typename C, typename D>
-		GLM_FUNC_DECL GLM_CONSTEXPR_SIMD tvec4(A a, B b, C c, D d);
-		template <typename A, typename B, typename C, typename D>
-		GLM_FUNC_DECL GLM_CONSTEXPR_CTOR tvec4(tvec1<A, P> const& a, tvec1<B, P> const& b, tvec1<C, P> const& c, tvec1<D, P> const& d);
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template<typename A, typename B, typename C, typename D>
+		GLM_FUNC_DECL GLM_CONSTEXPR_SIMD vec(A a, B b, C c, D d);
+		template<typename A, typename B, typename C, typename D>
+		GLM_FUNC_DECL GLM_CONSTEXPR_CTOR vec(vec<1, A, P> const& a, vec<1, B, P> const& b, vec<1, C, P> const& c, vec<1, D, P> const& d);
 
 		// -- Conversion vector constructors --
 
 		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename A, typename B, typename C, precision Q>
-		GLM_FUNC_DECL GLM_CONSTEXPR tvec4(tvec2<A, Q> const & a, B b, C c);
+		template<typename A, typename B, typename C, precision Q>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<2, A, Q> const & a, B b, C c);
 		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename A, typename B, typename C, precision Q>
-		GLM_FUNC_DECL GLM_CONSTEXPR tvec4(tvec2<A, Q> const & a, tvec1<B, Q> const & b, tvec1<C, Q> const & c);
+		template<typename A, typename B, typename C, precision Q>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<2, A, Q> const & a, vec<1, B, Q> const & b, vec<1, C, Q> const & c);
 		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename A, typename B, typename C, precision Q>
-		GLM_FUNC_DECL GLM_CONSTEXPR tvec4(A a, tvec2<B, Q> const & b, C c);
+		template<typename A, typename B, typename C, precision Q>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(A a, vec<2, B, Q> const & b, C c);
 		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename A, typename B, typename C, precision Q>
-		GLM_FUNC_DECL GLM_CONSTEXPR tvec4(tvec1<A, Q> const & a, tvec2<B, Q> const & b, tvec1<C, Q> const & c);
+		template<typename A, typename B, typename C, precision Q>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, A, Q> const & a, vec<2, B, Q> const & b, vec<1, C, Q> const & c);
 		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename A, typename B, typename C, precision Q>
-		GLM_FUNC_DECL GLM_CONSTEXPR tvec4(A a, B b, tvec2<C, Q> const & c);
+		template<typename A, typename B, typename C, precision Q>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(A a, B b, vec<2, C, Q> const & c);
 		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename A, typename B, typename C, precision Q>
-		GLM_FUNC_DECL GLM_CONSTEXPR tvec4(tvec1<A, Q> const & a, tvec1<B, Q> const & b, tvec2<C, Q> const & c);
+		template<typename A, typename B, typename C, precision Q>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, A, Q> const & a, vec<1, B, Q> const & b, vec<2, C, Q> const & c);
 		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename A, typename B, precision Q>
-		GLM_FUNC_DECL GLM_CONSTEXPR tvec4(tvec3<A, Q> const & a, B b);
+		template<typename A, typename B, precision Q>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<3, A, Q> const & a, B b);
 		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename A, typename B, precision Q>
-		GLM_FUNC_DECL GLM_CONSTEXPR tvec4(tvec3<A, Q> const & a, tvec1<B, Q> const & b);
+		template<typename A, typename B, precision Q>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<3, A, Q> const & a, vec<1, B, Q> const & b);
 		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename A, typename B, precision Q>
-		GLM_FUNC_DECL GLM_CONSTEXPR tvec4(A a, tvec3<B, Q> const & b);
+		template<typename A, typename B, precision Q>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(A a, vec<3, B, Q> const & b);
 		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename A, typename B, precision Q>
-		GLM_FUNC_DECL GLM_CONSTEXPR tvec4(tvec1<A, Q> const & a, tvec3<B, Q> const & b);
+		template<typename A, typename B, precision Q>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, A, Q> const & a, vec<3, B, Q> const & b);
 		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename A, typename B, precision Q>
-		GLM_FUNC_DECL GLM_CONSTEXPR tvec4(tvec2<A, Q> const & a, tvec2<B, Q> const & b);
+		template<typename A, typename B, precision Q>
+		GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<2, A, Q> const & a, vec<2, B, Q> const & b);
 
 		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename U, precision Q>
-		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tvec4(tvec4<U, Q> const& v);
+		template<typename U, precision Q>
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT vec(vec<4, U, Q> const& v);
 
 		// -- Swizzle constructors --
 #		if GLM_HAS_UNRESTRICTED_UNIONS && (GLM_SWIZZLE == GLM_SWIZZLE_ENABLED)
-			template <int E0, int E1, int E2, int E3>
-			GLM_FUNC_DECL tvec4(detail::_swizzle<4, T, P, glm::tvec4, E0, E1, E2, E3> const & that)
+			template<int E0, int E1, int E2, int E3>
+			GLM_FUNC_DECL vec(detail::_swizzle<4, T, P, E0, E1, E2, E3> const & that)
 			{
 				*this = that();
 			}
 
-			template <int E0, int E1, int F0, int F1>
-			GLM_FUNC_DECL tvec4(detail::_swizzle<2, T, P, glm::tvec2, E0, E1, -1, -2> const & v, detail::_swizzle<2, T, P, glm::tvec2, F0, F1, -1, -2> const & u)
+			template<int E0, int E1, int F0, int F1>
+			GLM_FUNC_DECL vec(detail::_swizzle<2, T, P, E0, E1, -1, -2> const & v, detail::_swizzle<2, T, P, F0, F1, -1, -2> const & u)
 			{
-				*this = tvec4<T, P>(v(), u());
+				*this = vec<4, T, P>(v(), u());
 			}
 
-			template <int E0, int E1>
-			GLM_FUNC_DECL tvec4(T const & x, T const & y, detail::_swizzle<2, T, P, glm::tvec2, E0, E1, -1, -2> const & v)
+			template<int E0, int E1>
+			GLM_FUNC_DECL vec(T const & x, T const & y, detail::_swizzle<2, T, P, E0, E1, -1, -2> const & v)
 			{
-				*this = tvec4<T, P>(x, y, v());
+				*this = vec<4, T, P>(x, y, v());
 			}
 
-			template <int E0, int E1>
-			GLM_FUNC_DECL tvec4(T const & x, detail::_swizzle<2, T, P, glm::tvec2, E0, E1, -1, -2> const & v, T const & w)
+			template<int E0, int E1>
+			GLM_FUNC_DECL vec(T const & x, detail::_swizzle<2, T, P, E0, E1, -1, -2> const & v, T const & w)
 			{
-				*this = tvec4<T, P>(x, v(), w);
+				*this = vec<4, T, P>(x, v(), w);
 			}
 
-			template <int E0, int E1>
-			GLM_FUNC_DECL tvec4(detail::_swizzle<2, T, P, glm::tvec2, E0, E1, -1, -2> const & v, T const & z, T const & w)
+			template<int E0, int E1>
+			GLM_FUNC_DECL vec(detail::_swizzle<2, T, P, E0, E1, -1, -2> const & v, T const & z, T const & w)
 			{
-				*this = tvec4<T, P>(v(), z, w);
+				*this = vec<4, T, P>(v(), z, w);
 			}
 
-			template <int E0, int E1, int E2>
-			GLM_FUNC_DECL tvec4(detail::_swizzle<3, T, P, glm::tvec3, E0, E1, E2, -1> const & v, T const & w)
+			template<int E0, int E1, int E2>
+			GLM_FUNC_DECL vec(detail::_swizzle<3, T, P, E0, E1, E2, -1> const & v, T const & w)
 			{
-				*this = tvec4<T, P>(v(), w);
+				*this = vec<4, T, P>(v(), w);
 			}
 
-			template <int E0, int E1, int E2>
-			GLM_FUNC_DECL tvec4(T const & x, detail::_swizzle<3, T, P, glm::tvec3, E0, E1, E2, -1> const & v)
+			template<int E0, int E1, int E2>
+			GLM_FUNC_DECL vec(T const & x, detail::_swizzle<3, T, P, E0, E1, E2, -1> const & v)
 			{
-				*this = tvec4<T, P>(x, v());
+				*this = vec<4, T, P>(x, v());
 			}
 #		endif// GLM_HAS_UNRESTRICTED_UNIONS && (GLM_SWIZZLE == GLM_SWIZZLE_ENABLED)
 
 		// -- Unary arithmetic operators --
 
-		GLM_FUNC_DECL tvec4<T, P> & operator=(tvec4<T, P> const & v) GLM_DEFAULT;
+		GLM_FUNC_DECL vec<4, T, P> & operator=(vec<4, T, P> const & v) GLM_DEFAULT;
 
-		template <typename U>
-		GLM_FUNC_DECL tvec4<T, P> & operator=(tvec4<U, P> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec4<T, P> & operator+=(U scalar);
-		template <typename U>
-		GLM_FUNC_DECL tvec4<T, P> & operator+=(tvec1<U, P> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec4<T, P> & operator+=(tvec4<U, P> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec4<T, P> & operator-=(U scalar);
-		template <typename U>
-		GLM_FUNC_DECL tvec4<T, P> & operator-=(tvec1<U, P> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec4<T, P> & operator-=(tvec4<U, P> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec4<T, P> & operator*=(U scalar);
-		template <typename U>
-		GLM_FUNC_DECL tvec4<T, P> & operator*=(tvec1<U, P> const& v);
-		template <typename U>
-		GLM_FUNC_DECL tvec4<T, P> & operator*=(tvec4<U, P> const& v);
-		template <typename U>
-		GLM_FUNC_DECL tvec4<T, P> & operator/=(U scalar);
-		template <typename U>
-		GLM_FUNC_DECL tvec4<T, P> & operator/=(tvec1<U, P> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec4<T, P> & operator/=(tvec4<U, P> const & v);
+		template<typename U>
+		GLM_FUNC_DECL vec<4, T, P> & operator=(vec<4, U, P> const & v);
+		template<typename U>
+		GLM_FUNC_DECL vec<4, T, P> & operator+=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL vec<4, T, P> & operator+=(vec<1, U, P> const & v);
+		template<typename U>
+		GLM_FUNC_DECL vec<4, T, P> & operator+=(vec<4, U, P> const & v);
+		template<typename U>
+		GLM_FUNC_DECL vec<4, T, P> & operator-=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL vec<4, T, P> & operator-=(vec<1, U, P> const & v);
+		template<typename U>
+		GLM_FUNC_DECL vec<4, T, P> & operator-=(vec<4, U, P> const & v);
+		template<typename U>
+		GLM_FUNC_DECL vec<4, T, P> & operator*=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL vec<4, T, P> & operator*=(vec<1, U, P> const& v);
+		template<typename U>
+		GLM_FUNC_DECL vec<4, T, P> & operator*=(vec<4, U, P> const& v);
+		template<typename U>
+		GLM_FUNC_DECL vec<4, T, P> & operator/=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL vec<4, T, P> & operator/=(vec<1, U, P> const & v);
+		template<typename U>
+		GLM_FUNC_DECL vec<4, T, P> & operator/=(vec<4, U, P> const & v);
 
 		// -- Increment and decrement operators --
 
-		GLM_FUNC_DECL tvec4<T, P> & operator++();
-		GLM_FUNC_DECL tvec4<T, P> & operator--();
-		GLM_FUNC_DECL tvec4<T, P> operator++(int);
-		GLM_FUNC_DECL tvec4<T, P> operator--(int);
+		GLM_FUNC_DECL vec<4, T, P> & operator++();
+		GLM_FUNC_DECL vec<4, T, P> & operator--();
+		GLM_FUNC_DECL vec<4, T, P> operator++(int);
+		GLM_FUNC_DECL vec<4, T, P> operator--(int);
 
 		// -- Unary bit operators --
 
-		template <typename U>
-		GLM_FUNC_DECL tvec4<T, P> & operator%=(U scalar);
-		template <typename U>
-		GLM_FUNC_DECL tvec4<T, P> & operator%=(tvec1<U, P> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec4<T, P> & operator%=(tvec4<U, P> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec4<T, P> & operator&=(U scalar);
-		template <typename U>
-		GLM_FUNC_DECL tvec4<T, P> & operator&=(tvec1<U, P> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec4<T, P> & operator&=(tvec4<U, P> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec4<T, P> & operator|=(U scalar);
-		template <typename U>
-		GLM_FUNC_DECL tvec4<T, P> & operator|=(tvec1<U, P> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec4<T, P> & operator|=(tvec4<U, P> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec4<T, P> & operator^=(U scalar);
-		template <typename U>
-		GLM_FUNC_DECL tvec4<T, P> & operator^=(tvec1<U, P> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec4<T, P> & operator^=(tvec4<U, P> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec4<T, P> & operator<<=(U scalar);
-		template <typename U>
-		GLM_FUNC_DECL tvec4<T, P> & operator<<=(tvec1<U, P> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec4<T, P> & operator<<=(tvec4<U, P> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec4<T, P> & operator>>=(U scalar);
-		template <typename U>
-		GLM_FUNC_DECL tvec4<T, P> & operator>>=(tvec1<U, P> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec4<T, P> & operator>>=(tvec4<U, P> const & v);
+		template<typename U>
+		GLM_FUNC_DECL vec<4, T, P> & operator%=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL vec<4, T, P> & operator%=(vec<1, U, P> const & v);
+		template<typename U>
+		GLM_FUNC_DECL vec<4, T, P> & operator%=(vec<4, U, P> const & v);
+		template<typename U>
+		GLM_FUNC_DECL vec<4, T, P> & operator&=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL vec<4, T, P> & operator&=(vec<1, U, P> const & v);
+		template<typename U>
+		GLM_FUNC_DECL vec<4, T, P> & operator&=(vec<4, U, P> const & v);
+		template<typename U>
+		GLM_FUNC_DECL vec<4, T, P> & operator|=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL vec<4, T, P> & operator|=(vec<1, U, P> const & v);
+		template<typename U>
+		GLM_FUNC_DECL vec<4, T, P> & operator|=(vec<4, U, P> const & v);
+		template<typename U>
+		GLM_FUNC_DECL vec<4, T, P> & operator^=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL vec<4, T, P> & operator^=(vec<1, U, P> const & v);
+		template<typename U>
+		GLM_FUNC_DECL vec<4, T, P> & operator^=(vec<4, U, P> const & v);
+		template<typename U>
+		GLM_FUNC_DECL vec<4, T, P> & operator<<=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL vec<4, T, P> & operator<<=(vec<1, U, P> const & v);
+		template<typename U>
+		GLM_FUNC_DECL vec<4, T, P> & operator<<=(vec<4, U, P> const & v);
+		template<typename U>
+		GLM_FUNC_DECL vec<4, T, P> & operator>>=(U scalar);
+		template<typename U>
+		GLM_FUNC_DECL vec<4, T, P> & operator>>=(vec<1, U, P> const & v);
+		template<typename U>
+		GLM_FUNC_DECL vec<4, T, P> & operator>>=(vec<4, U, P> const & v);
 	};
 
 	// -- Unary operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec4<T, P> operator+(tvec4<T, P> const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<4, T, P> operator+(vec<4, T, P> const & v);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec4<T, P> operator-(tvec4<T, P> const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<4, T, P> operator-(vec<4, T, P> const & v);
 
 	// -- Binary operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec4<T, P> operator+(tvec4<T, P> const & v, T scalar);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<4, T, P> operator+(vec<4, T, P> const & v, T scalar);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec4<T, P> operator+(tvec4<T, P> const & v1, tvec1<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<4, T, P> operator+(vec<4, T, P> const & v1, vec<1, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec4<T, P> operator+(T scalar, tvec4<T, P> const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<4, T, P> operator+(T scalar, vec<4, T, P> const & v);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec4<T, P> operator+(tvec1<T, P> const & v1, tvec4<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<4, T, P> operator+(vec<1, T, P> const & v1, vec<4, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec4<T, P> operator+(tvec4<T, P> const & v1, tvec4<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<4, T, P> operator+(vec<4, T, P> const & v1, vec<4, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec4<T, P> operator-(tvec4<T, P> const & v, T scalar);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<4, T, P> operator-(vec<4, T, P> const & v, T scalar);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec4<T, P> operator-(tvec4<T, P> const & v1, tvec1<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<4, T, P> operator-(vec<4, T, P> const & v1, vec<1, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec4<T, P> operator-(T scalar, tvec4<T, P> const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<4, T, P> operator-(T scalar, vec<4, T, P> const & v);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec4<T, P> operator-(tvec1<T, P> const & v1, tvec4<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<4, T, P> operator-(vec<1, T, P> const & v1, vec<4, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec4<T, P> operator-(tvec4<T, P> const & v1, tvec4<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<4, T, P> operator-(vec<4, T, P> const & v1, vec<4, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec4<T, P> operator*(tvec4<T, P> const & v, T scalar);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<4, T, P> operator*(vec<4, T, P> const & v, T scalar);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec4<T, P> operator*(tvec4<T, P> const & v1, tvec1<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<4, T, P> operator*(vec<4, T, P> const & v1, vec<1, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec4<T, P> operator*(T scalar, tvec4<T, P> const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<4, T, P> operator*(T scalar, vec<4, T, P> const & v);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec4<T, P> operator*(tvec1<T, P> const & v1, tvec4<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<4, T, P> operator*(vec<1, T, P> const & v1, vec<4, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec4<T, P> operator*(tvec4<T, P> const & v1, tvec4<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<4, T, P> operator*(vec<4, T, P> const & v1, vec<4, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec4<T, P> operator/(tvec4<T, P> const & v, T scalar);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<4, T, P> operator/(vec<4, T, P> const & v, T scalar);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec4<T, P> operator/(tvec4<T, P> const & v1, tvec1<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<4, T, P> operator/(vec<4, T, P> const & v1, vec<1, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec4<T, P> operator/(T scalar, tvec4<T, P> const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<4, T, P> operator/(T scalar, vec<4, T, P> const & v);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec4<T, P> operator/(tvec1<T, P> const & v1, tvec4<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<4, T, P> operator/(vec<1, T, P> const & v1, vec<4, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec4<T, P> operator/(tvec4<T, P> const & v1, tvec4<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<4, T, P> operator/(vec<4, T, P> const & v1, vec<4, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec4<T, P> operator%(tvec4<T, P> const & v, T scalar);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<4, T, P> operator%(vec<4, T, P> const & v, T scalar);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec4<T, P> operator%(tvec4<T, P> const & v, tvec1<T, P> const & scalar);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<4, T, P> operator%(vec<4, T, P> const & v, vec<1, T, P> const & scalar);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec4<T, P> operator%(T scalar, tvec4<T, P> const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<4, T, P> operator%(T scalar, vec<4, T, P> const & v);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec4<T, P> operator%(tvec1<T, P> const & scalar, tvec4<T, P> const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<4, T, P> operator%(vec<1, T, P> const & scalar, vec<4, T, P> const & v);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec4<T, P> operator%(tvec4<T, P> const & v1, tvec4<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<4, T, P> operator%(vec<4, T, P> const & v1, vec<4, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec4<T, P> operator&(tvec4<T, P> const & v, T scalar);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<4, T, P> operator&(vec<4, T, P> const & v, T scalar);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec4<T, P> operator&(tvec4<T, P> const & v, tvec1<T, P> const & scalar);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<4, T, P> operator&(vec<4, T, P> const & v, vec<1, T, P> const & scalar);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec4<T, P> operator&(T scalar, tvec4<T, P> const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<4, T, P> operator&(T scalar, vec<4, T, P> const & v);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec4<T, P> operator&(tvec1<T, P> const & scalar, tvec4<T, P> const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<4, T, P> operator&(vec<1, T, P> const & scalar, vec<4, T, P> const & v);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec4<T, P> operator&(tvec4<T, P> const & v1, tvec4<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<4, T, P> operator&(vec<4, T, P> const & v1, vec<4, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec4<T, P> operator|(tvec4<T, P> const & v, T scalar);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<4, T, P> operator|(vec<4, T, P> const & v, T scalar);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec4<T, P> operator|(tvec4<T, P> const & v, tvec1<T, P> const & scalar);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<4, T, P> operator|(vec<4, T, P> const & v, vec<1, T, P> const & scalar);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec4<T, P> operator|(T scalar, tvec4<T, P> const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<4, T, P> operator|(T scalar, vec<4, T, P> const & v);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec4<T, P> operator|(tvec1<T, P> const & scalar, tvec4<T, P> const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<4, T, P> operator|(vec<1, T, P> const & scalar, vec<4, T, P> const & v);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec4<T, P> operator|(tvec4<T, P> const & v1, tvec4<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<4, T, P> operator|(vec<4, T, P> const & v1, vec<4, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec4<T, P> operator^(tvec4<T, P> const & v, T scalar);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<4, T, P> operator^(vec<4, T, P> const & v, T scalar);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec4<T, P> operator^(tvec4<T, P> const & v, tvec1<T, P> const & scalar);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<4, T, P> operator^(vec<4, T, P> const & v, vec<1, T, P> const & scalar);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec4<T, P> operator^(T scalar, tvec4<T, P> const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<4, T, P> operator^(T scalar, vec<4, T, P> const & v);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec4<T, P> operator^(tvec1<T, P> const & scalar, tvec4<T, P> const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<4, T, P> operator^(vec<1, T, P> const & scalar, vec<4, T, P> const & v);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec4<T, P> operator^(tvec4<T, P> const & v1, tvec4<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<4, T, P> operator^(vec<4, T, P> const & v1, vec<4, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec4<T, P> operator<<(tvec4<T, P> const & v, T scalar);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<4, T, P> operator<<(vec<4, T, P> const & v, T scalar);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec4<T, P> operator<<(tvec4<T, P> const & v, tvec1<T, P> const & scalar);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<4, T, P> operator<<(vec<4, T, P> const & v, vec<1, T, P> const & scalar);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec4<T, P> operator<<(T scalar, tvec4<T, P> const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<4, T, P> operator<<(T scalar, vec<4, T, P> const & v);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec4<T, P> operator<<(tvec1<T, P> const & scalar, tvec4<T, P> const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<4, T, P> operator<<(vec<1, T, P> const & scalar, vec<4, T, P> const & v);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec4<T, P> operator<<(tvec4<T, P> const & v1, tvec4<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<4, T, P> operator<<(vec<4, T, P> const & v1, vec<4, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec4<T, P> operator>>(tvec4<T, P> const & v, T scalar);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<4, T, P> operator>>(vec<4, T, P> const & v, T scalar);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec4<T, P> operator>>(tvec4<T, P> const & v, tvec1<T, P> const & scalar);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<4, T, P> operator>>(vec<4, T, P> const & v, vec<1, T, P> const & scalar);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec4<T, P> operator>>(T scalar, tvec4<T, P> const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<4, T, P> operator>>(T scalar, vec<4, T, P> const & v);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec4<T, P> operator>>(tvec1<T, P> const & scalar, tvec4<T, P> const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<4, T, P> operator>>(vec<1, T, P> const & scalar, vec<4, T, P> const & v);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec4<T, P> operator>>(tvec4<T, P> const & v1, tvec4<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<4, T, P> operator>>(vec<4, T, P> const & v1, vec<4, T, P> const & v2);
 
-	template <typename T, precision P> 
-	GLM_FUNC_DECL tvec4<T, P> operator~(tvec4<T, P> const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<4, T, P> operator~(vec<4, T, P> const & v);
 
 	// -- Boolean operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL bool operator==(tvec4<T, P> const & v1, tvec4<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL bool operator==(vec<4, T, P> const & v1, vec<4, T, P> const & v2);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL bool operator!=(tvec4<T, P> const & v1, tvec4<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL bool operator!=(vec<4, T, P> const & v1, vec<4, T, P> const & v2);
 
-	template <precision P>
-	GLM_FUNC_DECL tvec4<bool, P> operator&&(tvec4<bool, P> const & v1, tvec4<bool, P> const & v2);
+	template<precision P>
+	GLM_FUNC_DECL vec<4, bool, P> operator&&(vec<4, bool, P> const & v1, vec<4, bool, P> const & v2);
 
-	template <precision P>
-	GLM_FUNC_DECL tvec4<bool, P> operator||(tvec4<bool, P> const & v1, tvec4<bool, P> const & v2);
+	template<precision P>
+	GLM_FUNC_DECL vec<4, bool, P> operator||(vec<4, bool, P> const & v1, vec<4, bool, P> const & v2);
 }//namespace glm
 
 #ifndef GLM_EXTERNAL_TEMPLATE
diff --git a/glm/detail/type_vec4.inl b/glm/detail/type_vec4.inl
index 2377e2b1..0310c50e 100644
--- a/glm/detail/type_vec4.inl
+++ b/glm/detail/type_vec4.inl
@@ -4,150 +4,150 @@
 namespace glm{
 namespace detail
 {
-	template <typename T>
+	template<typename T>
 	struct is_int
 	{
 		enum test {value = 0};
 	};
 
-	template <>
+	template<>
 	struct is_int<uint32>
 	{
 		enum test {value = ~0};
 	};
 
-	template <>
+	template<>
 	struct is_int<int32>
 	{
 		enum test {value = ~0};
 	};
 
-	template <>
+	template<>
 	struct is_int<uint64>
 	{
 		enum test {value = ~0};
 	};
 
-	template <>
+	template<>
 	struct is_int<int64>
 	{
 		enum test {value = ~0};
 	};
 
-	template <typename T, precision P, bool Aligned>
+	template<typename T, precision P, bool Aligned>
 	struct compute_vec4_add
 	{
-		GLM_FUNC_QUALIFIER static tvec4<T, P> call(tvec4<T, P> const & a, tvec4<T, P> const & b)
+		GLM_FUNC_QUALIFIER static vec<4, T, P> call(vec<4, T, P> const & a, vec<4, T, P> const & b)
 		{
-			return tvec4<T, P>(a.x + b.x, a.y + b.y, a.z + b.z, a.w + b.w);
+			return vec<4, T, P>(a.x + b.x, a.y + b.y, a.z + b.z, a.w + b.w);
 		}
 	};
 
-	template <typename T, precision P, bool Aligned>
+	template<typename T, precision P, bool Aligned>
 	struct compute_vec4_sub
 	{
-		GLM_FUNC_QUALIFIER static tvec4<T, P> call(tvec4<T, P> const & a, tvec4<T, P> const & b)
+		GLM_FUNC_QUALIFIER static vec<4, T, P> call(vec<4, T, P> const & a, vec<4, T, P> const & b)
 		{
-			return tvec4<T, P>(a.x - b.x, a.y - b.y, a.z - b.z, a.w - b.w);
+			return vec<4, T, P>(a.x - b.x, a.y - b.y, a.z - b.z, a.w - b.w);
 		}
 	};
 
-	template <typename T, precision P, bool Aligned>
+	template<typename T, precision P, bool Aligned>
 	struct compute_vec4_mul
 	{
-		GLM_FUNC_QUALIFIER static tvec4<T, P> call(tvec4<T, P> const & a, tvec4<T, P> const & b)
+		GLM_FUNC_QUALIFIER static vec<4, T, P> call(vec<4, T, P> const & a, vec<4, T, P> const & b)
 		{
-			return tvec4<T, P>(a.x * b.x, a.y * b.y, a.z * b.z, a.w * b.w);
+			return vec<4, T, P>(a.x * b.x, a.y * b.y, a.z * b.z, a.w * b.w);
 		}
 	};
 
-	template <typename T, precision P, bool Aligned>
+	template<typename T, precision P, bool Aligned>
 	struct compute_vec4_div
 	{
-		GLM_FUNC_QUALIFIER static tvec4<T, P> call(tvec4<T, P> const & a, tvec4<T, P> const & b)
+		GLM_FUNC_QUALIFIER static vec<4, T, P> call(vec<4, T, P> const & a, vec<4, T, P> const & b)
 		{
-			return tvec4<T, P>(a.x / b.x, a.y / b.y, a.z / b.z, a.w / b.w);
+			return vec<4, T, P>(a.x / b.x, a.y / b.y, a.z / b.z, a.w / b.w);
 		}
 	};
 
-	template <typename T, precision P, bool Aligned>
+	template<typename T, precision P, bool Aligned>
 	struct compute_vec4_mod
 	{
-		GLM_FUNC_QUALIFIER static tvec4<T, P> call(tvec4<T, P> const & a, tvec4<T, P> const & b)
+		GLM_FUNC_QUALIFIER static vec<4, T, P> call(vec<4, T, P> const & a, vec<4, T, P> const & b)
 		{
-			return tvec4<T, P>(a.x % b.x, a.y % b.y, a.z % b.z, a.w % b.w);
+			return vec<4, T, P>(a.x % b.x, a.y % b.y, a.z % b.z, a.w % b.w);
 		}
 	};
 
-	template <typename T, precision P, int IsInt, std::size_t Size, bool Aligned>
+	template<typename T, precision P, int IsInt, std::size_t Size, bool Aligned>
 	struct compute_vec4_and
 	{
-		GLM_FUNC_QUALIFIER static tvec4<T, P> call(tvec4<T, P> const & a, tvec4<T, P> const & b)
+		GLM_FUNC_QUALIFIER static vec<4, T, P> call(vec<4, T, P> const & a, vec<4, T, P> const & b)
 		{
-			return tvec4<T, P>(a.x & b.x, a.y & b.y, a.z & b.z, a.w & b.w);
+			return vec<4, T, P>(a.x & b.x, a.y & b.y, a.z & b.z, a.w & b.w);
 		}
 	};
 
-	template <typename T, precision P, int IsInt, std::size_t Size, bool Aligned>
+	template<typename T, precision P, int IsInt, std::size_t Size, bool Aligned>
 	struct compute_vec4_or
 	{
-		GLM_FUNC_QUALIFIER static tvec4<T, P> call(tvec4<T, P> const & a, tvec4<T, P> const & b)
+		GLM_FUNC_QUALIFIER static vec<4, T, P> call(vec<4, T, P> const & a, vec<4, T, P> const & b)
 		{
-			return tvec4<T, P>(a.x | b.x, a.y | b.y, a.z | b.z, a.w | b.w);
+			return vec<4, T, P>(a.x | b.x, a.y | b.y, a.z | b.z, a.w | b.w);
 		}
 	};
 
-	template <typename T, precision P, int IsInt, std::size_t Size, bool Aligned>
+	template<typename T, precision P, int IsInt, std::size_t Size, bool Aligned>
 	struct compute_vec4_xor
 	{
-		GLM_FUNC_QUALIFIER static tvec4<T, P> call(tvec4<T, P> const & a, tvec4<T, P> const & b)
+		GLM_FUNC_QUALIFIER static vec<4, T, P> call(vec<4, T, P> const & a, vec<4, T, P> const & b)
 		{
-			return tvec4<T, P>(a.x ^ b.x, a.y ^ b.y, a.z ^ b.z, a.w ^ b.w);
+			return vec<4, T, P>(a.x ^ b.x, a.y ^ b.y, a.z ^ b.z, a.w ^ b.w);
 		}
 	};
 
-	template <typename T, precision P, int IsInt, std::size_t Size, bool Aligned>
+	template<typename T, precision P, int IsInt, std::size_t Size, bool Aligned>
 	struct compute_vec4_shift_left
 	{
-		GLM_FUNC_QUALIFIER static tvec4<T, P> call(tvec4<T, P> const & a, tvec4<T, P> const & b)
+		GLM_FUNC_QUALIFIER static vec<4, T, P> call(vec<4, T, P> const & a, vec<4, T, P> const & b)
 		{
-			return tvec4<T, P>(a.x << b.x, a.y << b.y, a.z << b.z, a.w << b.w);
+			return vec<4, T, P>(a.x << b.x, a.y << b.y, a.z << b.z, a.w << b.w);
 		}
 	};
 
-	template <typename T, precision P, int IsInt, std::size_t Size, bool Aligned>
+	template<typename T, precision P, int IsInt, std::size_t Size, bool Aligned>
 	struct compute_vec4_shift_right
 	{
-		GLM_FUNC_QUALIFIER static tvec4<T, P> call(tvec4<T, P> const & a, tvec4<T, P> const & b)
+		GLM_FUNC_QUALIFIER static vec<4, T, P> call(vec<4, T, P> const & a, vec<4, T, P> const & b)
 		{
-			return tvec4<T, P>(a.x >> b.x, a.y >> b.y, a.z >> b.z, a.w >> b.w);
+			return vec<4, T, P>(a.x >> b.x, a.y >> b.y, a.z >> b.z, a.w >> b.w);
 		}
 	};
 
-	template <typename T, precision P, int IsInt, std::size_t Size, bool Aligned>
+	template<typename T, precision P, int IsInt, std::size_t Size, bool Aligned>
 	struct compute_vec4_equal
 	{
-		GLM_FUNC_QUALIFIER static bool call(tvec4<T, P> const & v1, tvec4<T, P> const & v2)
+		GLM_FUNC_QUALIFIER static bool call(vec<4, T, P> const & v1, vec<4, T, P> const & v2)
 		{
 			return (v1.x == v2.x) && (v1.y == v2.y) && (v1.z == v2.z) && (v1.w == v2.w);
 		}
 	};
 
-	template <typename T, precision P, int IsInt, std::size_t Size, bool Aligned>
+	template<typename T, precision P, int IsInt, std::size_t Size, bool Aligned>
 	struct compute_vec4_nequal
 	{
-		GLM_FUNC_QUALIFIER static bool call(tvec4<T, P> const & v1, tvec4<T, P> const & v2)
+		GLM_FUNC_QUALIFIER static bool call(vec<4, T, P> const & v1, vec<4, T, P> const & v2)
 		{
 			return (v1.x != v2.x) || (v1.y != v2.y) || (v1.z != v2.z) || (v1.w != v2.w);
 		}
 	};
 
-	template <typename T, precision P, int IsInt, std::size_t Size, bool Aligned>
+	template<typename T, precision P, int IsInt, std::size_t Size, bool Aligned>
 	struct compute_vec4_bitwise_not
 	{
-		GLM_FUNC_QUALIFIER static tvec4<T, P> call(tvec4<T, P> const & v)
+		GLM_FUNC_QUALIFIER static vec<4, T, P> call(vec<4, T, P> const & v)
 		{
-			return tvec4<T, P>(~v.x, ~v.y, ~v.z, ~v.w);
+			return vec<4, T, P>(~v.x, ~v.y, ~v.z, ~v.w);
 		}
 	};
 }//namespace detail
@@ -155,8 +155,8 @@ namespace detail
 	// -- Implicit basic constructors --
 
 #	if !GLM_HAS_DEFAULTED_FUNCTIONS || !defined(GLM_FORCE_NO_CTOR_INIT)
-		template <typename T, precision P>
-		GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD tvec4<T, P>::tvec4()
+		template<typename T, precision P>
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD vec<4, T, P>::vec()
 #			ifndef GLM_FORCE_NO_CTOR_INIT
 				: x(0), y(0), z(0), w(0)
 #			endif
@@ -164,48 +164,48 @@ namespace detail
 #	endif//!GLM_HAS_DEFAULTED_FUNCTIONS
 
 #	if !GLM_HAS_DEFAULTED_FUNCTIONS
-		template <typename T, precision P>
-		GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD tvec4<T, P>::tvec4(tvec4<T, P> const & v)
+		template<typename T, precision P>
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD vec<4, T, P>::vec(vec<4, T, P> const & v)
 			: x(v.x), y(v.y), z(v.z), w(v.w)
 		{}
 #	endif//!GLM_HAS_DEFAULTED_FUNCTIONS
 
-	template <typename T, precision P>
-	template <precision Q>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD tvec4<T, P>::tvec4(tvec4<T, Q> const & v)
+	template<typename T, precision P>
+	template<precision Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD vec<4, T, P>::vec(vec<4, T, Q> const & v)
 		: x(v.x), y(v.y), z(v.z), w(v.w)
 	{}
 
 	// -- Explicit basic constructors --
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD tvec4<T, P>::tvec4(ctor)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD vec<4, T, P>::vec(ctor)
 	{}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD tvec4<T, P>::tvec4(T scalar)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD vec<4, T, P>::vec(T scalar)
 		: x(scalar), y(scalar), z(scalar), w(scalar)
 	{}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD tvec4<T, P>::tvec4(T a, T b, T c, T d)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD vec<4, T, P>::vec(T a, T b, T c, T d)
 		: x(a), y(b), z(c), w(d)
 	{}
 
 	// -- Conversion scalar constructors --
 
-	template <typename T, precision P>
-	template <typename A, typename B, typename C, typename D>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD tvec4<T, P>::tvec4(A a, B b, C c, D d) :
+	template<typename T, precision P>
+	template<typename A, typename B, typename C, typename D>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD vec<4, T, P>::vec(A a, B b, C c, D d) :
 		x(static_cast<T>(a)),
 		y(static_cast<T>(b)),
 		z(static_cast<T>(c)),
 		w(static_cast<T>(d))
 	{}
 
-	template <typename T, precision P>
-	template <typename A, typename B, typename C, typename D>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR tvec4<T, P>::tvec4(tvec1<A, P> const & a, tvec1<B, P> const & b, tvec1<C, P> const & c, tvec1<D, P> const & d) :
+	template<typename T, precision P>
+	template<typename A, typename B, typename C, typename D>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<4, T, P>::vec(vec<1, A, P> const & a, vec<1, B, P> const & b, vec<1, C, P> const & c, vec<1, D, P> const & d) :
 		x(static_cast<T>(a.x)),
 		y(static_cast<T>(b.x)),
 		z(static_cast<T>(c.x)),
@@ -214,108 +214,108 @@ namespace detail
 
 	// -- Conversion vector constructors --
 
-	template <typename T, precision P>
-	template <typename A, typename B, typename C, precision Q>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec4<T, P>::tvec4(tvec2<A, Q> const & a, B b, C c) :
+	template<typename T, precision P>
+	template<typename A, typename B, typename C, precision Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, P>::vec(vec<2, A, Q> const & a, B b, C c) :
 		x(static_cast<T>(a.x)),
 		y(static_cast<T>(a.y)),
 		z(static_cast<T>(b)),
 		w(static_cast<T>(c))
 	{}
 
-	template <typename T, precision P>
-	template <typename A, typename B, typename C, precision Q>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec4<T, P>::tvec4(tvec2<A, Q> const & a, tvec1<B, Q> const & b, tvec1<C, Q> const & c) :
+	template<typename T, precision P>
+	template<typename A, typename B, typename C, precision Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, P>::vec(vec<2, A, Q> const & a, vec<1, B, Q> const & b, vec<1, C, Q> const & c) :
 		x(static_cast<T>(a.x)),
 		y(static_cast<T>(a.y)),
 		z(static_cast<T>(b.x)),
 		w(static_cast<T>(c.x))
 	{}
 
-	template <typename T, precision P>
-	template <typename A, typename B, typename C, precision Q>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec4<T, P>::tvec4(A s1, tvec2<B, Q> const & v, C s2) :
+	template<typename T, precision P>
+	template<typename A, typename B, typename C, precision Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, P>::vec(A s1, vec<2, B, Q> const & v, C s2) :
 		x(static_cast<T>(s1)),
 		y(static_cast<T>(v.x)),
 		z(static_cast<T>(v.y)),
 		w(static_cast<T>(s2))
 	{}
 
-	template <typename T, precision P>
-	template <typename A, typename B, typename C, precision Q>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec4<T, P>::tvec4(tvec1<A, Q> const & a, tvec2<B, Q> const & b, tvec1<C, Q> const & c) :
+	template<typename T, precision P>
+	template<typename A, typename B, typename C, precision Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, P>::vec(vec<1, A, Q> const & a, vec<2, B, Q> const & b, vec<1, C, Q> const & c) :
 		x(static_cast<T>(a.x)),
 		y(static_cast<T>(b.x)),
 		z(static_cast<T>(b.y)),
 		w(static_cast<T>(c.x))
 	{}
 
-	template <typename T, precision P>
-	template <typename A, typename B, typename C, precision Q>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec4<T, P>::tvec4(A s1, B s2, tvec2<C, Q> const & v) :
+	template<typename T, precision P>
+	template<typename A, typename B, typename C, precision Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, P>::vec(A s1, B s2, vec<2, C, Q> const & v) :
 		x(static_cast<T>(s1)),
 		y(static_cast<T>(s2)),
 		z(static_cast<T>(v.x)),
 		w(static_cast<T>(v.y))
 	{}
 
-	template <typename T, precision P>
-	template <typename A, typename B, typename C, precision Q>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec4<T, P>::tvec4(tvec1<A, Q> const & a, tvec1<B, Q> const & b, tvec2<C, Q> const & c) :
+	template<typename T, precision P>
+	template<typename A, typename B, typename C, precision Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, P>::vec(vec<1, A, Q> const & a, vec<1, B, Q> const & b, vec<2, C, Q> const & c) :
 		x(static_cast<T>(a.x)),
 		y(static_cast<T>(b.x)),
 		z(static_cast<T>(c.x)),
 		w(static_cast<T>(c.y))
 	{}
 
-	template <typename T, precision P>
-	template <typename A, typename B, precision Q>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec4<T, P>::tvec4(tvec3<A, Q> const & a, B b) :
+	template<typename T, precision P>
+	template<typename A, typename B, precision Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, P>::vec(vec<3, A, Q> const & a, B b) :
 		x(static_cast<T>(a.x)),
 		y(static_cast<T>(a.y)),
 		z(static_cast<T>(a.z)),
 		w(static_cast<T>(b))
 	{}
 
-	template <typename T, precision P>
-	template <typename A, typename B, precision Q>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec4<T, P>::tvec4(tvec3<A, Q> const & a, tvec1<B, Q> const & b) :
+	template<typename T, precision P>
+	template<typename A, typename B, precision Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, P>::vec(vec<3, A, Q> const & a, vec<1, B, Q> const & b) :
 		x(static_cast<T>(a.x)),
 		y(static_cast<T>(a.y)),
 		z(static_cast<T>(a.z)),
 		w(static_cast<T>(b.x))
 	{}
 
-	template <typename T, precision P>
-	template <typename A, typename B, precision Q>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec4<T, P>::tvec4(A a, tvec3<B, Q> const & b) :
+	template<typename T, precision P>
+	template<typename A, typename B, precision Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, P>::vec(A a, vec<3, B, Q> const & b) :
 		x(static_cast<T>(a)),
 		y(static_cast<T>(b.x)),
 		z(static_cast<T>(b.y)),
 		w(static_cast<T>(b.z))
 	{}
 
-	template <typename T, precision P>
-	template <typename A, typename B, precision Q>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec4<T, P>::tvec4(tvec1<A, Q> const & a, tvec3<B, Q> const & b) :
+	template<typename T, precision P>
+	template<typename A, typename B, precision Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, P>::vec(vec<1, A, Q> const & a, vec<3, B, Q> const & b) :
 		x(static_cast<T>(a.x)),
 		y(static_cast<T>(b.x)),
 		z(static_cast<T>(b.y)),
 		w(static_cast<T>(b.z))
 	{}
 
-	template <typename T, precision P>
-	template <typename A, typename B, precision Q>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec4<T, P>::tvec4(tvec2<A, Q> const & a, tvec2<B, Q> const & b) :
+	template<typename T, precision P>
+	template<typename A, typename B, precision Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, P>::vec(vec<2, A, Q> const & a, vec<2, B, Q> const & b) :
 		x(static_cast<T>(a.x)),
 		y(static_cast<T>(a.y)),
 		z(static_cast<T>(b.x)),
 		w(static_cast<T>(b.y))
 	{}
 
-	template <typename T, precision P>
-	template <typename U, precision Q>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec4<T, P>::tvec4(tvec4<U, Q> const & v) :
+	template<typename T, precision P>
+	template<typename U, precision Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, P>::vec(vec<4, U, Q> const & v) :
 		x(static_cast<T>(v.x)),
 		y(static_cast<T>(v.y)),
 		z(static_cast<T>(v.z)),
@@ -324,15 +324,15 @@ namespace detail
 
 	// -- Component accesses --
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER T & tvec4<T, P>::operator[](typename tvec4<T, P>::length_type i)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER T & vec<4, T, P>::operator[](typename vec<4, T, P>::length_type i)
 	{
 		assert(i >= 0 && i < this->length());
 		return (&x)[i];
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER T const & tvec4<T, P>::operator[](typename tvec4<T, P>::length_type i) const
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER T const & vec<4, T, P>::operator[](typename vec<4, T, P>::length_type i) const
 	{
 		assert(i >= 0 && i < this->length());
 		return (&x)[i];
@@ -341,8 +341,8 @@ namespace detail
 	// -- Unary arithmetic operators --
 
 #	if !GLM_HAS_DEFAULTED_FUNCTIONS
-		template <typename T, precision P>
-		GLM_FUNC_QUALIFIER tvec4<T, P>& tvec4<T, P>::operator=(tvec4<T, P> const & v)
+		template<typename T, precision P>
+		GLM_FUNC_QUALIFIER vec<4, T, P>& vec<4, T, P>::operator=(vec<4, T, P> const & v)
 		{
 			this->x = v.x;
 			this->y = v.y;
@@ -352,9 +352,9 @@ namespace detail
 		}
 #	endif//!GLM_HAS_DEFAULTED_FUNCTIONS
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tvec4<T, P>& tvec4<T, P>::operator=(tvec4<U, P> const & v)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<4, T, P>& vec<4, T, P>::operator=(vec<4, U, P> const & v)
 	{
 		this->x = static_cast<T>(v.x);
 		this->y = static_cast<T>(v.y);
@@ -363,94 +363,94 @@ namespace detail
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tvec4<T, P> & tvec4<T, P>::operator+=(U scalar)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator+=(U scalar)
 	{
-		return (*this = detail::compute_vec4_add<T, P, detail::is_aligned<P>::value>::call(*this, tvec4<T, P>(scalar)));
+		return (*this = detail::compute_vec4_add<T, P, detail::is_aligned<P>::value>::call(*this, vec<4, T, P>(scalar)));
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tvec4<T, P> & tvec4<T, P>::operator+=(tvec1<U, P> const & v)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator+=(vec<1, U, P> const & v)
 	{
-		return (*this = detail::compute_vec4_add<T, P, detail::is_aligned<P>::value>::call(*this, tvec4<T, P>(v.x)));
+		return (*this = detail::compute_vec4_add<T, P, detail::is_aligned<P>::value>::call(*this, vec<4, T, P>(v.x)));
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tvec4<T, P> & tvec4<T, P>::operator+=(tvec4<U, P> const & v)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator+=(vec<4, U, P> const & v)
 	{
-		return (*this = detail::compute_vec4_add<T, P, detail::is_aligned<P>::value>::call(*this, tvec4<T, P>(v)));
+		return (*this = detail::compute_vec4_add<T, P, detail::is_aligned<P>::value>::call(*this, vec<4, T, P>(v)));
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tvec4<T, P> & tvec4<T, P>::operator-=(U scalar)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator-=(U scalar)
 	{
-		return (*this = detail::compute_vec4_sub<T, P, detail::is_aligned<P>::value>::call(*this, tvec4<T, P>(scalar)));
+		return (*this = detail::compute_vec4_sub<T, P, detail::is_aligned<P>::value>::call(*this, vec<4, T, P>(scalar)));
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tvec4<T, P> & tvec4<T, P>::operator-=(tvec1<U, P> const & v)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator-=(vec<1, U, P> const & v)
 	{
-		return (*this = detail::compute_vec4_sub<T, P, detail::is_aligned<P>::value>::call(*this, tvec4<T, P>(v.x)));
+		return (*this = detail::compute_vec4_sub<T, P, detail::is_aligned<P>::value>::call(*this, vec<4, T, P>(v.x)));
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tvec4<T, P> & tvec4<T, P>::operator-=(tvec4<U, P> const & v)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator-=(vec<4, U, P> const & v)
 	{
-		return (*this = detail::compute_vec4_sub<T, P, detail::is_aligned<P>::value>::call(*this, tvec4<T, P>(v)));
+		return (*this = detail::compute_vec4_sub<T, P, detail::is_aligned<P>::value>::call(*this, vec<4, T, P>(v)));
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tvec4<T, P> & tvec4<T, P>::operator*=(U scalar)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator*=(U scalar)
 	{
-		return (*this = detail::compute_vec4_mul<T, P, detail::is_aligned<P>::value>::call(*this, tvec4<T, P>(scalar)));
+		return (*this = detail::compute_vec4_mul<T, P, detail::is_aligned<P>::value>::call(*this, vec<4, T, P>(scalar)));
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tvec4<T, P> & tvec4<T, P>::operator*=(tvec1<U, P> const & v)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator*=(vec<1, U, P> const & v)
 	{
-		return (*this = detail::compute_vec4_mul<T, P, detail::is_aligned<P>::value>::call(*this, tvec4<T, P>(v.x)));
+		return (*this = detail::compute_vec4_mul<T, P, detail::is_aligned<P>::value>::call(*this, vec<4, T, P>(v.x)));
 	}
 
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tvec4<T, P> & tvec4<T, P>::operator*=(tvec4<U, P> const & v)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator*=(vec<4, U, P> const & v)
 	{
-		return (*this = detail::compute_vec4_mul<T, P, detail::is_aligned<P>::value>::call(*this, tvec4<T, P>(v)));
+		return (*this = detail::compute_vec4_mul<T, P, detail::is_aligned<P>::value>::call(*this, vec<4, T, P>(v)));
 	}
 
-	template <typename T, precision P>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T, P> & tvec4<T, P>::operator/=(U scalar)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator/=(U scalar)
 	{
-		return (*this = detail::compute_vec4_div<T, P, detail::is_aligned<P>::value>::call(*this, tvec4<T, P>(scalar)));
+		return (*this = detail::compute_vec4_div<T, P, detail::is_aligned<P>::value>::call(*this, vec<4, T, P>(scalar)));
 	}
 
-	template <typename T, precision P>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T, P> & tvec4<T, P>::operator/=(tvec1<U, P> const & v)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator/=(vec<1, U, P> const & v)
 	{
-		return (*this = detail::compute_vec4_div<T, P, detail::is_aligned<P>::value>::call(*this, tvec4<T, P>(v.x)));
+		return (*this = detail::compute_vec4_div<T, P, detail::is_aligned<P>::value>::call(*this, vec<4, T, P>(v.x)));
 	}
 
-	template <typename T, precision P>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T, P> & tvec4<T, P>::operator/=(tvec4<U, P> const & v)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator/=(vec<4, U, P> const & v)
 	{
-		return (*this = detail::compute_vec4_div<T, P, detail::is_aligned<P>::value>::call(*this, tvec4<T, P>(v)));
+		return (*this = detail::compute_vec4_div<T, P, detail::is_aligned<P>::value>::call(*this, vec<4, T, P>(v)));
 	}
 
 	// -- Increment and decrement operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> & tvec4<T, P>::operator++()
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator++()
 	{
 		++this->x;
 		++this->y;
@@ -459,8 +459,8 @@ namespace detail
 		return *this;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> & tvec4<T, P>::operator--()
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator--()
 	{
 		--this->x;
 		--this->y;
@@ -469,498 +469,498 @@ namespace detail
 		return *this;
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tvec4<T, P> tvec4<T, P>::operator++(int)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, T, P> vec<4, T, P>::operator++(int)
 	{
-		tvec4<T, P> Result(*this);
+		vec<4, T, P> Result(*this);
 		++*this;
 		return Result;
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tvec4<T, P> tvec4<T, P>::operator--(int)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, T, P> vec<4, T, P>::operator--(int)
 	{
-		tvec4<T, P> Result(*this);
+		vec<4, T, P> Result(*this);
 		--*this;
 		return Result;
 	}
 
 	// -- Unary bit operators --
 
-	template <typename T, precision P>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T, P> & tvec4<T, P>::operator%=(U scalar)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator%=(U scalar)
 	{
-		return (*this = detail::compute_vec4_mod<T, P, detail::is_aligned<P>::value>::call(*this, tvec4<T, P>(scalar)));
+		return (*this = detail::compute_vec4_mod<T, P, detail::is_aligned<P>::value>::call(*this, vec<4, T, P>(scalar)));
 	}
 
-	template <typename T, precision P>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T, P> & tvec4<T, P>::operator%=(tvec1<U, P> const& v)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator%=(vec<1, U, P> const& v)
 	{
-		return (*this = detail::compute_vec4_mod<T, P, detail::is_aligned<P>::value>::call(*this, tvec4<T, P>(v)));
+		return (*this = detail::compute_vec4_mod<T, P, detail::is_aligned<P>::value>::call(*this, vec<4, T, P>(v)));
 	}
 
-	template <typename T, precision P>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T, P> & tvec4<T, P>::operator%=(tvec4<U, P> const& v)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator%=(vec<4, U, P> const& v)
 	{
-		return (*this = detail::compute_vec4_mod<T, P, detail::is_aligned<P>::value>::call(*this, tvec4<T, P>(v)));
+		return (*this = detail::compute_vec4_mod<T, P, detail::is_aligned<P>::value>::call(*this, vec<4, T, P>(v)));
 	}
 
-	template <typename T, precision P>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T, P> & tvec4<T, P>::operator&=(U scalar)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator&=(U scalar)
 	{
-		return (*this = detail::compute_vec4_and<T, P, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<P>::value>::call(*this, tvec4<T, P>(scalar)));
+		return (*this = detail::compute_vec4_and<T, P, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<P>::value>::call(*this, vec<4, T, P>(scalar)));
 	}
 
-	template <typename T, precision P>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T, P> & tvec4<T, P>::operator&=(tvec1<U, P> const & v)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator&=(vec<1, U, P> const & v)
 	{
-		return (*this = detail::compute_vec4_and<T, P, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<P>::value>::call(*this, tvec4<T, P>(v)));
+		return (*this = detail::compute_vec4_and<T, P, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<P>::value>::call(*this, vec<4, T, P>(v)));
 	}
 
-	template <typename T, precision P>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T, P> & tvec4<T, P>::operator&=(tvec4<U, P> const & v)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator&=(vec<4, U, P> const & v)
 	{
-		return (*this = detail::compute_vec4_and<T, P, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<P>::value>::call(*this, tvec4<T, P>(v)));
+		return (*this = detail::compute_vec4_and<T, P, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<P>::value>::call(*this, vec<4, T, P>(v)));
 	}
 
-	template <typename T, precision P>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T, P> & tvec4<T, P>::operator|=(U scalar)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator|=(U scalar)
 	{
-		return (*this = detail::compute_vec4_or<T, P, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<P>::value>::call(*this, tvec4<T, P>(scalar)));
+		return (*this = detail::compute_vec4_or<T, P, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<P>::value>::call(*this, vec<4, T, P>(scalar)));
 	}
 
-	template <typename T, precision P>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T, P> & tvec4<T, P>::operator|=(tvec1<U, P> const & v)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator|=(vec<1, U, P> const & v)
 	{
-		return (*this = detail::compute_vec4_or<T, P, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<P>::value>::call(*this, tvec4<T, P>(v)));
+		return (*this = detail::compute_vec4_or<T, P, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<P>::value>::call(*this, vec<4, T, P>(v)));
 	}
 
-	template <typename T, precision P>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T, P> & tvec4<T, P>::operator|=(tvec4<U, P> const & v)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator|=(vec<4, U, P> const & v)
 	{
-		return (*this = detail::compute_vec4_or<T, P, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<P>::value>::call(*this, tvec4<T, P>(v)));
+		return (*this = detail::compute_vec4_or<T, P, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<P>::value>::call(*this, vec<4, T, P>(v)));
 	}
 
-	template <typename T, precision P>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T, P> & tvec4<T, P>::operator^=(U scalar)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator^=(U scalar)
 	{
-		return (*this = detail::compute_vec4_xor<T, P, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<P>::value>::call(*this, tvec4<T, P>(scalar)));
+		return (*this = detail::compute_vec4_xor<T, P, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<P>::value>::call(*this, vec<4, T, P>(scalar)));
 	}
 
-	template <typename T, precision P>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T, P> & tvec4<T, P>::operator^=(tvec1<U, P> const & v)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator^=(vec<1, U, P> const & v)
 	{
-		return (*this = detail::compute_vec4_xor<T, P, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<P>::value>::call(*this, tvec4<T, P>(v)));
+		return (*this = detail::compute_vec4_xor<T, P, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<P>::value>::call(*this, vec<4, T, P>(v)));
 	}
 
-	template <typename T, precision P>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T, P> & tvec4<T, P>::operator^=(tvec4<U, P> const & v)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator^=(vec<4, U, P> const & v)
 	{
-		return (*this = detail::compute_vec4_xor<T, P, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<P>::value>::call(*this, tvec4<T, P>(v)));
+		return (*this = detail::compute_vec4_xor<T, P, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<P>::value>::call(*this, vec<4, T, P>(v)));
 	}
 
-	template <typename T, precision P>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T, P> & tvec4<T, P>::operator<<=(U scalar)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator<<=(U scalar)
 	{
-		return (*this = detail::compute_vec4_shift_left<T, P, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<P>::value>::call(*this, tvec4<T, P>(scalar)));
+		return (*this = detail::compute_vec4_shift_left<T, P, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<P>::value>::call(*this, vec<4, T, P>(scalar)));
 	}
 
-	template <typename T, precision P>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T, P> & tvec4<T, P>::operator<<=(tvec1<U, P> const & v)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator<<=(vec<1, U, P> const & v)
 	{
-		return (*this = detail::compute_vec4_shift_left<T, P, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<P>::value>::call(*this, tvec4<T, P>(v)));
+		return (*this = detail::compute_vec4_shift_left<T, P, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<P>::value>::call(*this, vec<4, T, P>(v)));
 	}
 
-	template <typename T, precision P>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T, P> & tvec4<T, P>::operator<<=(tvec4<U, P> const & v)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator<<=(vec<4, U, P> const & v)
 	{
-		return (*this = detail::compute_vec4_shift_left<T, P, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<P>::value>::call(*this, tvec4<T, P>(v)));
+		return (*this = detail::compute_vec4_shift_left<T, P, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<P>::value>::call(*this, vec<4, T, P>(v)));
 	}
 
-	template <typename T, precision P>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T, P> & tvec4<T, P>::operator>>=(U scalar)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator>>=(U scalar)
 	{
-		return (*this = detail::compute_vec4_shift_right<T, P, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<P>::value>::call(*this, tvec4<T, P>(scalar)));
+		return (*this = detail::compute_vec4_shift_right<T, P, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<P>::value>::call(*this, vec<4, T, P>(scalar)));
 	}
 
-	template <typename T, precision P>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T, P> & tvec4<T, P>::operator>>=(tvec1<U, P> const & v)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator>>=(vec<1, U, P> const & v)
 	{
-		return (*this = detail::compute_vec4_shift_right<T, P, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<P>::value>::call(*this, tvec4<T, P>(v)));
+		return (*this = detail::compute_vec4_shift_right<T, P, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<P>::value>::call(*this, vec<4, T, P>(v)));
 	}
 
-	template <typename T, precision P>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T, P> & tvec4<T, P>::operator>>=(tvec4<U, P> const & v)
+	template<typename T, precision P>
+	template<typename U>
+	GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator>>=(vec<4, U, P> const & v)
 	{
-		return (*this = detail::compute_vec4_shift_right<T, P, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<P>::value>::call(*this, tvec4<T, P>(v)));
+		return (*this = detail::compute_vec4_shift_right<T, P, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<P>::value>::call(*this, vec<4, T, P>(v)));
 	}
 
 	// -- Unary constant operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> operator+(tvec4<T, P> const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, T, P> operator+(vec<4, T, P> const & v)
 	{
 		return v;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> operator-(tvec4<T, P> const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, T, P> operator-(vec<4, T, P> const & v)
 	{
-		return tvec4<T, P>(0) -= v;
+		return vec<4, T, P>(0) -= v;
 	}
 
 	// -- Binary arithmetic operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> operator+(tvec4<T, P> const & v, T scalar)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, T, P> operator+(vec<4, T, P> const & v, T scalar)
 	{
-		return tvec4<T, P>(v) += scalar;
+		return vec<4, T, P>(v) += scalar;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> operator+(tvec4<T, P> const & v1, tvec1<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, T, P> operator+(vec<4, T, P> const & v1, vec<1, T, P> const & v2)
 	{
-		return tvec4<T, P>(v1) += v2;
+		return vec<4, T, P>(v1) += v2;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> operator+(T scalar, tvec4<T, P> const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, T, P> operator+(T scalar, vec<4, T, P> const & v)
 	{
-		return tvec4<T, P>(v) += scalar;
+		return vec<4, T, P>(v) += scalar;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> operator+(tvec1<T, P> const & v1, tvec4<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, T, P> operator+(vec<1, T, P> const & v1, vec<4, T, P> const & v2)
 	{
-		return tvec4<T, P>(v2) += v1;
+		return vec<4, T, P>(v2) += v1;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> operator+(tvec4<T, P> const & v1, tvec4<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, T, P> operator+(vec<4, T, P> const & v1, vec<4, T, P> const & v2)
 	{
-		return tvec4<T, P>(v1) += v2;
+		return vec<4, T, P>(v1) += v2;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> operator-(tvec4<T, P> const & v, T scalar)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, T, P> operator-(vec<4, T, P> const & v, T scalar)
 	{
-		return tvec4<T, P>(v) -= scalar;
+		return vec<4, T, P>(v) -= scalar;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> operator-(tvec4<T, P> const & v1, tvec1<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, T, P> operator-(vec<4, T, P> const & v1, vec<1, T, P> const & v2)
 	{
-		return tvec4<T, P>(v1) -= v2;
+		return vec<4, T, P>(v1) -= v2;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> operator-(T scalar, tvec4<T, P> const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, T, P> operator-(T scalar, vec<4, T, P> const & v)
 	{
-		return tvec4<T, P>(scalar) -= v;
+		return vec<4, T, P>(scalar) -= v;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> operator-(tvec1<T, P> const & v1, tvec4<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, T, P> operator-(vec<1, T, P> const & v1, vec<4, T, P> const & v2)
 	{
-		return tvec4<T, P>(v1.x) -= v2;
+		return vec<4, T, P>(v1.x) -= v2;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> operator-(tvec4<T, P> const & v1, tvec4<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, T, P> operator-(vec<4, T, P> const & v1, vec<4, T, P> const & v2)
 	{
-		return tvec4<T, P>(v1) -= v2;
+		return vec<4, T, P>(v1) -= v2;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> operator*(tvec4<T, P> const & v, T scalar)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, T, P> operator*(vec<4, T, P> const & v, T scalar)
 	{
-		return tvec4<T, P>(v) *= scalar;
+		return vec<4, T, P>(v) *= scalar;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> operator*(tvec4<T, P> const & v1, tvec1<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, T, P> operator*(vec<4, T, P> const & v1, vec<1, T, P> const & v2)
 	{
-		return tvec4<T, P>(v1) *= v2;
+		return vec<4, T, P>(v1) *= v2;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> operator*(T scalar, tvec4<T, P> const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, T, P> operator*(T scalar, vec<4, T, P> const & v)
 	{
-		return tvec4<T, P>(v) *= scalar;
+		return vec<4, T, P>(v) *= scalar;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> operator*(tvec1<T, P> const & v1, tvec4<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, T, P> operator*(vec<1, T, P> const & v1, vec<4, T, P> const & v2)
 	{
-		return tvec4<T, P>(v2) *= v1;
+		return vec<4, T, P>(v2) *= v1;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> operator*(tvec4<T, P> const & v1, tvec4<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, T, P> operator*(vec<4, T, P> const & v1, vec<4, T, P> const & v2)
 	{
-		return tvec4<T, P>(v1) *= v2;
+		return vec<4, T, P>(v1) *= v2;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> operator/(tvec4<T, P> const & v, T scalar)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, T, P> operator/(vec<4, T, P> const & v, T scalar)
 	{
-		return tvec4<T, P>(v) /= scalar;
+		return vec<4, T, P>(v) /= scalar;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> operator/(tvec4<T, P> const & v1, tvec1<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, T, P> operator/(vec<4, T, P> const & v1, vec<1, T, P> const & v2)
 	{
-		return tvec4<T, P>(v1) /= v2;
+		return vec<4, T, P>(v1) /= v2;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> operator/(T scalar, tvec4<T, P> const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, T, P> operator/(T scalar, vec<4, T, P> const & v)
 	{
-		return tvec4<T, P>(scalar) /= v;
+		return vec<4, T, P>(scalar) /= v;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> operator/(tvec1<T, P> const & v1, tvec4<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, T, P> operator/(vec<1, T, P> const & v1, vec<4, T, P> const & v2)
 	{
-		return tvec4<T, P>(v1.x) /= v2;
+		return vec<4, T, P>(v1.x) /= v2;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> operator/(tvec4<T, P> const & v1, tvec4<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, T, P> operator/(vec<4, T, P> const & v1, vec<4, T, P> const & v2)
 	{
-		return tvec4<T, P>(v1) /= v2;
+		return vec<4, T, P>(v1) /= v2;
 	}
 
 	// -- Binary bit operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> operator%(tvec4<T, P> const & v, T scalar)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, T, P> operator%(vec<4, T, P> const & v, T scalar)
 	{
-		return tvec4<T, P>(v) %= scalar;
+		return vec<4, T, P>(v) %= scalar;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> operator%(tvec4<T, P> const & v1, tvec1<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, T, P> operator%(vec<4, T, P> const & v1, vec<1, T, P> const & v2)
 	{
-		return tvec4<T, P>(v1) %= v2.x;
+		return vec<4, T, P>(v1) %= v2.x;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> operator%(T scalar, tvec4<T, P> const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, T, P> operator%(T scalar, vec<4, T, P> const & v)
 	{
-		return tvec4<T, P>(scalar) %= v;
+		return vec<4, T, P>(scalar) %= v;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> operator%(tvec1<T, P> const & scalar, tvec4<T, P> const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, T, P> operator%(vec<1, T, P> const & scalar, vec<4, T, P> const & v)
 	{
-		return tvec4<T, P>(scalar.x) %= v;
+		return vec<4, T, P>(scalar.x) %= v;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> operator%(tvec4<T, P> const & v1, tvec4<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, T, P> operator%(vec<4, T, P> const & v1, vec<4, T, P> const & v2)
 	{
-		return tvec4<T, P>(v1) %= v2;
+		return vec<4, T, P>(v1) %= v2;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> operator&(tvec4<T, P> const & v, T scalar)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, T, P> operator&(vec<4, T, P> const & v, T scalar)
 	{
-		return tvec4<T, P>(v) &= scalar;
+		return vec<4, T, P>(v) &= scalar;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> operator&(tvec4<T, P> const & v, tvec1<T, P> const & scalar)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, T, P> operator&(vec<4, T, P> const & v, vec<1, T, P> const & scalar)
 	{
-		return tvec4<T, P>(v) &= scalar;
+		return vec<4, T, P>(v) &= scalar;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> operator&(T scalar, tvec4<T, P> const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, T, P> operator&(T scalar, vec<4, T, P> const & v)
 	{
-		return tvec4<T, P>(scalar) &= v;
+		return vec<4, T, P>(scalar) &= v;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> operator&(tvec1<T, P> const & v1, tvec4<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, T, P> operator&(vec<1, T, P> const & v1, vec<4, T, P> const & v2)
 	{
-		return tvec4<T, P>(v1.x) &= v2;
+		return vec<4, T, P>(v1.x) &= v2;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> operator&(tvec4<T, P> const & v1, tvec4<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, T, P> operator&(vec<4, T, P> const & v1, vec<4, T, P> const & v2)
 	{
-		return tvec4<T, P>(v1) &= v2;
+		return vec<4, T, P>(v1) &= v2;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> operator|(tvec4<T, P> const & v, T scalar)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, T, P> operator|(vec<4, T, P> const & v, T scalar)
 	{
-		return tvec4<T, P>(v) |= scalar;
+		return vec<4, T, P>(v) |= scalar;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> operator|(tvec4<T, P> const & v1, tvec1<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, T, P> operator|(vec<4, T, P> const & v1, vec<1, T, P> const & v2)
 	{
-		return tvec4<T, P>(v1) |= v2.x;
+		return vec<4, T, P>(v1) |= v2.x;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> operator|(T scalar, tvec4<T, P> const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, T, P> operator|(T scalar, vec<4, T, P> const & v)
 	{
-		return tvec4<T, P>(scalar) |= v;
+		return vec<4, T, P>(scalar) |= v;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> operator|(tvec1<T, P> const & v1, tvec4<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, T, P> operator|(vec<1, T, P> const & v1, vec<4, T, P> const & v2)
 	{
-		return tvec4<T, P>(v1.x) |= v2;
+		return vec<4, T, P>(v1.x) |= v2;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> operator|(tvec4<T, P> const & v1, tvec4<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, T, P> operator|(vec<4, T, P> const & v1, vec<4, T, P> const & v2)
 	{
-		return tvec4<T, P>(v1) |= v2;
+		return vec<4, T, P>(v1) |= v2;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> operator^(tvec4<T, P> const & v, T scalar)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, T, P> operator^(vec<4, T, P> const & v, T scalar)
 	{
-		return tvec4<T, P>(v) ^= scalar;
+		return vec<4, T, P>(v) ^= scalar;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> operator^(tvec4<T, P> const & v1, tvec1<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, T, P> operator^(vec<4, T, P> const & v1, vec<1, T, P> const & v2)
 	{
-		return tvec4<T, P>(v1) ^= v2.x;
+		return vec<4, T, P>(v1) ^= v2.x;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> operator^(T scalar, tvec4<T, P> const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, T, P> operator^(T scalar, vec<4, T, P> const & v)
 	{
-		return tvec4<T, P>(scalar) ^= v;
+		return vec<4, T, P>(scalar) ^= v;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> operator^(tvec1<T, P> const & v1, tvec4<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, T, P> operator^(vec<1, T, P> const & v1, vec<4, T, P> const & v2)
 	{
-		return tvec4<T, P>(v1.x) ^= v2;
+		return vec<4, T, P>(v1.x) ^= v2;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> operator^(tvec4<T, P> const & v1, tvec4<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, T, P> operator^(vec<4, T, P> const & v1, vec<4, T, P> const & v2)
 	{
-		return tvec4<T, P>(v1) ^= v2;
+		return vec<4, T, P>(v1) ^= v2;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> operator<<(tvec4<T, P> const & v, T scalar)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, T, P> operator<<(vec<4, T, P> const & v, T scalar)
 	{
-		return tvec4<T, P>(v) <<= scalar;
+		return vec<4, T, P>(v) <<= scalar;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> operator<<(tvec4<T, P> const & v1, tvec1<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, T, P> operator<<(vec<4, T, P> const & v1, vec<1, T, P> const & v2)
 	{
-		return tvec4<T, P>(v1) <<= v2.x;
+		return vec<4, T, P>(v1) <<= v2.x;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> operator<<(T scalar, tvec4<T, P> const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, T, P> operator<<(T scalar, vec<4, T, P> const & v)
 	{
-		return tvec4<T, P>(scalar) <<= v;
+		return vec<4, T, P>(scalar) <<= v;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> operator<<(tvec1<T, P> const & v1, tvec4<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, T, P> operator<<(vec<1, T, P> const & v1, vec<4, T, P> const & v2)
 	{
-		return tvec4<T, P>(v1.x) <<= v2;
+		return vec<4, T, P>(v1.x) <<= v2;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> operator<<(tvec4<T, P> const & v1, tvec4<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, T, P> operator<<(vec<4, T, P> const & v1, vec<4, T, P> const & v2)
 	{
-		return tvec4<T, P>(v1) <<= v2;
+		return vec<4, T, P>(v1) <<= v2;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> operator>>(tvec4<T, P> const & v, T scalar)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, T, P> operator>>(vec<4, T, P> const & v, T scalar)
 	{
-		return tvec4<T, P>(v) >>= scalar;
+		return vec<4, T, P>(v) >>= scalar;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> operator>>(tvec4<T, P> const & v1, tvec1<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, T, P> operator>>(vec<4, T, P> const & v1, vec<1, T, P> const & v2)
 	{
-		return tvec4<T, P>(v1) >>= v2.x;
+		return vec<4, T, P>(v1) >>= v2.x;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> operator>>(T scalar, tvec4<T, P> const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, T, P> operator>>(T scalar, vec<4, T, P> const & v)
 	{
-		return tvec4<T, P>(scalar) >>= v;
+		return vec<4, T, P>(scalar) >>= v;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> operator>>(tvec1<T, P> const & v1, tvec4<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, T, P> operator>>(vec<1, T, P> const & v1, vec<4, T, P> const & v2)
 	{
-		return tvec4<T, P>(v1.x) >>= v2;
+		return vec<4, T, P>(v1.x) >>= v2;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> operator>>(tvec4<T, P> const & v1, tvec4<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, T, P> operator>>(vec<4, T, P> const & v1, vec<4, T, P> const & v2)
 	{
-		return tvec4<T, P>(v1) >>= v2;
+		return vec<4, T, P>(v1) >>= v2;
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tvec4<T, P> operator~(tvec4<T, P> const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, T, P> operator~(vec<4, T, P> const & v)
 	{
 		return detail::compute_vec4_bitwise_not<T, P, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<P>::value>::call(v);
 	}
 
 	// -- Boolean operators --
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER bool operator==(tvec4<T, P> const & v1, tvec4<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER bool operator==(vec<4, T, P> const & v1, vec<4, T, P> const & v2)
 	{
 		return detail::compute_vec4_equal<T, P, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<P>::value>::call(v1, v2);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER bool operator!=(tvec4<T, P> const & v1, tvec4<T, P> const & v2)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER bool operator!=(vec<4, T, P> const & v1, vec<4, T, P> const & v2)
 	{
 		return detail::compute_vec4_nequal<T, P, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<P>::value>::call(v1, v2);
 	}
 
-	template <precision P>
-	GLM_FUNC_QUALIFIER tvec4<bool, P> operator&&(tvec4<bool, P> const & v1, tvec4<bool, P> const & v2)
+	template<precision P>
+	GLM_FUNC_QUALIFIER vec<4, bool, P> operator&&(vec<4, bool, P> const & v1, vec<4, bool, P> const & v2)
 	{
-		return tvec4<bool, P>(v1.x && v2.x, v1.y && v2.y, v1.z && v2.z, v1.w && v2.w);
+		return vec<4, bool, P>(v1.x && v2.x, v1.y && v2.y, v1.z && v2.z, v1.w && v2.w);
 	}
 
-	template <precision P>
-	GLM_FUNC_QUALIFIER tvec4<bool, P> operator||(tvec4<bool, P> const & v1, tvec4<bool, P> const & v2)
+	template<precision P>
+	GLM_FUNC_QUALIFIER vec<4, bool, P> operator||(vec<4, bool, P> const & v1, vec<4, bool, P> const & v2)
 	{
-		return tvec4<bool, P>(v1.x || v2.x, v1.y || v2.y, v1.z || v2.z, v1.w || v2.w);
+		return vec<4, bool, P>(v1.x || v2.x, v1.y || v2.y, v1.z || v2.z, v1.w || v2.w);
 	}
 }//namespace glm
 
diff --git a/glm/detail/type_vec4_simd.inl b/glm/detail/type_vec4_simd.inl
index 90652fd9..3511ed7c 100644
--- a/glm/detail/type_vec4_simd.inl
+++ b/glm/detail/type_vec4_simd.inl
@@ -7,14 +7,14 @@ namespace glm{
 namespace detail
 {
 #	if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED
-	template <precision P, int E0, int E1, int E2, int E3>
-	struct _swizzle_base1<4, float, P, glm::tvec4, E0,E1,E2,E3, true> : public _swizzle_base0<float, 4>
+	template<precision P, int E0, int E1, int E2, int E3>
+	struct _swizzle_base1<4, float, P, E0,E1,E2,E3, true> : public _swizzle_base0<float, 4>
 	{ 
-		GLM_FUNC_QUALIFIER tvec4<float, P> operator ()()  const
+		GLM_FUNC_QUALIFIER vec<4, float, P> operator ()()  const
 		{
 			__m128 data = *reinterpret_cast<__m128 const*>(&this->_buffer);
 
-			tvec4<float, P> Result(uninitialize);
+			vec<4, float, P> Result(uninitialize);
 #			if GLM_ARCH & GLM_ARCH_AVX_BIT
 				Result.data = _mm_permute_ps(data, _MM_SHUFFLE(E3, E2, E1, E0));
 #			else
@@ -24,315 +24,315 @@ namespace detail
 		}
 	};
 
-	template <precision P, int E0, int E1, int E2, int E3>
-	struct _swizzle_base1<4, int32, P, glm::tvec4, E0,E1,E2,E3, true> : public _swizzle_base0<int32, 4>
+	template<precision P, int E0, int E1, int E2, int E3>
+	struct _swizzle_base1<4, int32, P, E0,E1,E2,E3, true> : public _swizzle_base0<int32, 4>
 	{ 
-		GLM_FUNC_QUALIFIER tvec4<int32, P> operator ()()  const
+		GLM_FUNC_QUALIFIER vec<4, int32, P> operator ()()  const
 		{
 			__m128i data = *reinterpret_cast<__m128i const*>(&this->_buffer);
 
-			tvec4<int32, P> Result(uninitialize);
+			vec<4, int32, P> Result(uninitialize);
 			Result.data = _mm_shuffle_epi32(data, _MM_SHUFFLE(E3, E2, E1, E0));
 			return Result;
 		}
 	};
 
-	template <precision P, int E0, int E1, int E2, int E3>
-	struct _swizzle_base1<4, uint32, P, glm::tvec4, E0,E1,E2,E3, true> : public _swizzle_base0<uint32, 4>
+	template<precision P, int E0, int E1, int E2, int E3>
+	struct _swizzle_base1<4, uint32, P, E0,E1,E2,E3, true> : public _swizzle_base0<uint32, 4>
 	{ 
-		GLM_FUNC_QUALIFIER tvec4<uint32, P> operator ()()  const
+		GLM_FUNC_QUALIFIER vec<4, uint32, P> operator ()()  const
 		{
 			__m128i data = *reinterpret_cast<__m128i const*>(&this->_buffer);
 
-			tvec4<uint32, P> Result(uninitialize);
+			vec<4, uint32, P> Result(uninitialize);
 			Result.data = _mm_shuffle_epi32(data, _MM_SHUFFLE(E3, E2, E1, E0));
 			return Result;
 		}
 	};
 #	endif// GLM_SWIZZLE == GLM_SWIZZLE_ENABLED
 
-	template <precision P>
+	template<precision P>
 	struct compute_vec4_add<float, P, true>
 	{
-		static tvec4<float, P> call(tvec4<float, P> const & a, tvec4<float, P> const & b)
+		static vec<4, float, P> call(vec<4, float, P> const & a, vec<4, float, P> const & b)
 		{
-			tvec4<float, P> Result(uninitialize);
+			vec<4, float, P> Result(uninitialize);
 			Result.data = _mm_add_ps(a.data, b.data);
 			return Result;
 		}
 	};
 
 #	if GLM_ARCH & GLM_ARCH_AVX_BIT
-	template <precision P>
+	template<precision P>
 	struct compute_vec4_add<double, P, true>
 	{
-		static tvec4<double, P> call(tvec4<double, P> const & a, tvec4<double, P> const & b)
+		static vec<4, double, P> call(vec<4, double, P> const & a, vec<4, double, P> const & b)
 		{
-			tvec4<double, P> Result(uninitialize);
+			vec<4, double, P> Result(uninitialize);
 			Result.data = _mm256_add_pd(a.data, b.data);
 			return Result;
 		}
 	};
 #	endif
 
-	template <precision P>
+	template<precision P>
 	struct compute_vec4_sub<float, P, true>
 	{
-		static tvec4<float, P> call(tvec4<float, P> const & a, tvec4<float, P> const & b)
+		static vec<4, float, P> call(vec<4, float, P> const & a, vec<4, float, P> const & b)
 		{
-			tvec4<float, P> Result(uninitialize);
+			vec<4, float, P> Result(uninitialize);
 			Result.data = _mm_sub_ps(a.data, b.data);
 			return Result;
 		}
 	};
 
 #	if GLM_ARCH & GLM_ARCH_AVX_BIT
-	template <precision P>
+	template<precision P>
 	struct compute_vec4_sub<double, P, true>
 	{
-		static tvec4<double, P> call(tvec4<double, P> const & a, tvec4<double, P> const & b)
+		static vec<4, double, P> call(vec<4, double, P> const & a, vec<4, double, P> const & b)
 		{
-			tvec4<double, P> Result(uninitialize);
+			vec<4, double, P> Result(uninitialize);
 			Result.data = _mm256_sub_pd(a.data, b.data);
 			return Result;
 		}
 	};
 #	endif
 
-	template <precision P>
+	template<precision P>
 	struct compute_vec4_mul<float, P, true>
 	{
-		static tvec4<float, P> call(tvec4<float, P> const & a, tvec4<float, P> const & b)
+		static vec<4, float, P> call(vec<4, float, P> const & a, vec<4, float, P> const & b)
 		{
-			tvec4<float, P> Result(uninitialize);
+			vec<4, float, P> Result(uninitialize);
 			Result.data = _mm_mul_ps(a.data, b.data);
 			return Result;
 		}
 	};
 
 #	if GLM_ARCH & GLM_ARCH_AVX_BIT
-	template <precision P>
+	template<precision P>
 	struct compute_vec4_mul<double, P, true>
 	{
-		static tvec4<double, P> call(tvec4<double, P> const & a, tvec4<double, P> const & b)
+		static vec<4, double, P> call(vec<4, double, P> const & a, vec<4, double, P> const & b)
 		{
-			tvec4<double, P> Result(uninitialize);
+			vec<4, double, P> Result(uninitialize);
 			Result.data = _mm256_mul_pd(a.data, b.data);
 			return Result;
 		}
 	};
 #	endif
 
-	template <precision P>
+	template<precision P>
 	struct compute_vec4_div<float, P, true>
 	{
-		static tvec4<float, P> call(tvec4<float, P> const & a, tvec4<float, P> const & b)
+		static vec<4, float, P> call(vec<4, float, P> const & a, vec<4, float, P> const & b)
 		{
-			tvec4<float, P> Result(uninitialize);
+			vec<4, float, P> Result(uninitialize);
 			Result.data = _mm_div_ps(a.data, b.data);
 			return Result;
 		}
 	};
 
 	#	if GLM_ARCH & GLM_ARCH_AVX_BIT
-	template <precision P>
+	template<precision P>
 	struct compute_vec4_div<double, P, true>
 	{
-		static tvec4<double, P> call(tvec4<double, P> const & a, tvec4<double, P> const & b)
+		static vec<4, double, P> call(vec<4, double, P> const & a, vec<4, double, P> const & b)
 		{
-			tvec4<double, P> Result(uninitialize);
+			vec<4, double, P> Result(uninitialize);
 			Result.data = _mm256_div_pd(a.data, b.data);
 			return Result;
 		}
 	};
 #	endif
 
-	template <>
+	template<>
 	struct compute_vec4_div<float, aligned_lowp, true>
 	{
-		static tvec4<float, aligned_lowp> call(tvec4<float, aligned_lowp> const & a, tvec4<float, aligned_lowp> const & b)
+		static vec<4, float, aligned_lowp> call(vec<4, float, aligned_lowp> const & a, vec<4, float, aligned_lowp> const & b)
 		{
-			tvec4<float, aligned_lowp> Result(uninitialize);
+			vec<4, float, aligned_lowp> Result(uninitialize);
 			Result.data = _mm_mul_ps(a.data, _mm_rcp_ps(b.data));
 			return Result;
 		}
 	};
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	struct compute_vec4_and<T, P, true, 32, true>
 	{
-		static tvec4<T, P> call(tvec4<T, P> const& a, tvec4<T, P> const& b)
+		static vec<4, T, P> call(vec<4, T, P> const& a, vec<4, T, P> const& b)
 		{
-			tvec4<T, P> Result(uninitialize);
+			vec<4, T, P> Result(uninitialize);
 			Result.data = _mm_and_si128(a.data, b.data);
 			return Result;
 		}
 	};
 
 #	if GLM_ARCH & GLM_ARCH_AVX2_BIT
-	template <typename T, precision P>
+	template<typename T, precision P>
 	struct compute_vec4_and<T, P, true, 64, true>
 	{
-		static tvec4<T, P> call(tvec4<T, P> const& a, tvec4<T, P> const& b)
+		static vec<4, T, P> call(vec<4, T, P> const& a, vec<4, T, P> const& b)
 		{
-			tvec4<T, P> Result(uninitialize);
+			vec<4, T, P> Result(uninitialize);
 			Result.data = _mm256_and_si256(a.data, b.data);
 			return Result;
 		}
 	};
 #	endif
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	struct compute_vec4_or<T, P, true, 32, true>
 	{
-		static tvec4<T, P> call(tvec4<T, P> const& a, tvec4<T, P> const& b)
+		static vec<4, T, P> call(vec<4, T, P> const& a, vec<4, T, P> const& b)
 		{
-			tvec4<T, P> Result(uninitialize);
+			vec<4, T, P> Result(uninitialize);
 			Result.data = _mm_or_si128(a.data, b.data);
 			return Result;
 		}
 	};
 
 #	if GLM_ARCH & GLM_ARCH_AVX2_BIT
-	template <typename T, precision P>
+	template<typename T, precision P>
 	struct compute_vec4_or<T, P, true, 64, true>
 	{
-		static tvec4<T, P> call(tvec4<T, P> const& a, tvec4<T, P> const& b)
+		static vec<4, T, P> call(vec<4, T, P> const& a, vec<4, T, P> const& b)
 		{
-			tvec4<T, P> Result(uninitialize);
+			vec<4, T, P> Result(uninitialize);
 			Result.data = _mm256_or_si256(a.data, b.data);
 			return Result;
 		}
 	};
 #	endif
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	struct compute_vec4_xor<T, P, true, 32, true>
 	{
-		static tvec4<T, P> call(tvec4<T, P> const& a, tvec4<T, P> const& b)
+		static vec<4, T, P> call(vec<4, T, P> const& a, vec<4, T, P> const& b)
 		{
-			tvec4<T, P> Result(uninitialize);
+			vec<4, T, P> Result(uninitialize);
 			Result.data = _mm_xor_si128(a.data, b.data);
 			return Result;
 		}
 	};
 
 #	if GLM_ARCH & GLM_ARCH_AVX2_BIT
-	template <typename T, precision P>
+	template<typename T, precision P>
 	struct compute_vec4_xor<T, P, true, 64, true>
 	{
-		static tvec4<T, P> call(tvec4<T, P> const& a, tvec4<T, P> const& b)
+		static vec<4, T, P> call(vec<4, T, P> const& a, vec<4, T, P> const& b)
 		{
-			tvec4<T, P> Result(uninitialize);
+			vec<4, T, P> Result(uninitialize);
 			Result.data = _mm256_xor_si256(a.data, b.data);
 			return Result;
 		}
 	};
 #	endif
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	struct compute_vec4_shift_left<T, P, true, 32, true>
 	{
-		static tvec4<T, P> call(tvec4<T, P> const& a, tvec4<T, P> const& b)
+		static vec<4, T, P> call(vec<4, T, P> const& a, vec<4, T, P> const& b)
 		{
-			tvec4<T, P> Result(uninitialize);
+			vec<4, T, P> Result(uninitialize);
 			Result.data = _mm_sll_epi32(a.data, b.data);
 			return Result;
 		}
 	};
 
 #	if GLM_ARCH & GLM_ARCH_AVX2_BIT
-	template <typename T, precision P>
+	template<typename T, precision P>
 	struct compute_vec4_shift_left<T, P, true, 64, true>
 	{
-		static tvec4<T, P> call(tvec4<T, P> const& a, tvec4<T, P> const& b)
+		static vec<4, T, P> call(vec<4, T, P> const& a, vec<4, T, P> const& b)
 		{
-			tvec4<T, P> Result(uninitialize);
+			vec<4, T, P> Result(uninitialize);
 			Result.data = _mm256_sll_epi64(a.data, b.data);
 			return Result;
 		}
 	};
 #	endif
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	struct compute_vec4_shift_right<T, P, true, 32, true>
 	{
-		static tvec4<T, P> call(tvec4<T, P> const& a, tvec4<T, P> const& b)
+		static vec<4, T, P> call(vec<4, T, P> const& a, vec<4, T, P> const& b)
 		{
-			tvec4<T, P> Result(uninitialize);
+			vec<4, T, P> Result(uninitialize);
 			Result.data = _mm_srl_epi32(a.data, b.data);
 			return Result;
 		}
 	};
 
 #	if GLM_ARCH & GLM_ARCH_AVX2_BIT
-	template <typename T, precision P>
+	template<typename T, precision P>
 	struct compute_vec4_shift_right<T, P, true, 64, true>
 	{
-		static tvec4<T, P> call(tvec4<T, P> const& a, tvec4<T, P> const& b)
+		static vec<4, T, P> call(vec<4, T, P> const& a, vec<4, T, P> const& b)
 		{
-			tvec4<T, P> Result(uninitialize);
+			vec<4, T, P> Result(uninitialize);
 			Result.data = _mm256_srl_epi64(a.data, b.data);
 			return Result;
 		}
 	};
 #	endif
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	struct compute_vec4_bitwise_not<T, P, true, 32, true>
 	{
-		static tvec4<T, P> call(tvec4<T, P> const & v)
+		static vec<4, T, P> call(vec<4, T, P> const & v)
 		{
-			tvec4<T, P> Result(uninitialize);
+			vec<4, T, P> Result(uninitialize);
 			Result.data = _mm_xor_si128(v.data, _mm_set1_epi32(-1));
 			return Result;
 		}
 	};
 
 #	if GLM_ARCH & GLM_ARCH_AVX2_BIT
-	template <typename T, precision P>
+	template<typename T, precision P>
 	struct compute_vec4_bitwise_not<T, P, true, 64, true>
 	{
-		static tvec4<T, P> call(tvec4<T, P> const & v)
+		static vec<4, T, P> call(vec<4, T, P> const & v)
 		{
-			tvec4<T, P> Result(uninitialize);
+			vec<4, T, P> Result(uninitialize);
 			Result.data = _mm256_xor_si256(v.data, _mm_set1_epi32(-1));
 			return Result;
 		}
 	};
 #	endif
 
-	template <precision P>
+	template<precision P>
 	struct compute_vec4_equal<float, P, false, 32, true>
 	{
-		static bool call(tvec4<float, P> const & v1, tvec4<float, P> const & v2)
+		static bool call(vec<4, float, P> const & v1, vec<4, float, P> const & v2)
 		{
 			return _mm_movemask_ps(_mm_cmpeq_ps(v1.data, v2.data)) != 0;
 		}
 	};
 
-	template <precision P>
+	template<precision P>
 	struct compute_vec4_equal<int32, P, true, 32, true>
 	{
-		static bool call(tvec4<int32, P> const & v1, tvec4<int32, P> const & v2)
+		static bool call(vec<4, int32, P> const & v1, vec<4, int32, P> const & v2)
 		{
 			return _mm_movemask_epi8(_mm_cmpeq_epi32(v1.data, v2.data)) != 0;
 		}
 	};
 
-	template <precision P>
+	template<precision P>
 	struct compute_vec4_nequal<float, P, false, 32, true>
 	{
-		static bool call(tvec4<float, P> const & v1, tvec4<float, P> const & v2)
+		static bool call(vec<4, float, P> const & v1, vec<4, float, P> const & v2)
 		{
 			return _mm_movemask_ps(_mm_cmpneq_ps(v1.data, v2.data)) != 0;
 		}
 	};
 
-	template <precision P>
+	template<precision P>
 	struct compute_vec4_nequal<int32, P, true, 32, true>
 	{
-		static bool call(tvec4<int32, P> const & v1, tvec4<int32, P> const & v2)
+		static bool call(vec<4, int32, P> const & v1, vec<4, int32, P> const & v2)
 		{
 			return _mm_movemask_epi8(_mm_cmpneq_epi32(v1.data, v2.data)) != 0;
 		}
@@ -340,140 +340,140 @@ namespace detail
 }//namespace detail
 
 #	if !GLM_HAS_DEFAULTED_FUNCTIONS
-		template <>
-		GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD tvec4<float, aligned_lowp>::tvec4()
+		template<>
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD vec<4, float, aligned_lowp>::vec()
 #			ifndef GLM_FORCE_NO_CTOR_INIT
 				: data(_mm_setzero_ps())
 #			endif
 		{}
 
-		template <>
-		GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD tvec4<float, aligned_mediump>::tvec4()
+		template<>
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD vec<4, float, aligned_mediump>::vec()
 #			ifndef GLM_FORCE_NO_CTOR_INIT
 			: data(_mm_setzero_ps())
 #			endif
 		{}
 
-		template <>
-		GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD tvec4<float, aligned_highp>::tvec4()
+		template<>
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD vec<4, float, aligned_highp>::vec()
 #			ifndef GLM_FORCE_NO_CTOR_INIT
 			: data(_mm_setzero_ps())
 #			endif
 		{}
 #	endif//!GLM_HAS_DEFAULTED_FUNCTIONS
 
-	template <>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD tvec4<float, aligned_lowp>::tvec4(float s) :
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD vec<4, float, aligned_lowp>::vec(float s) :
 		data(_mm_set1_ps(s))
 	{}
 
-	template <>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD tvec4<float, aligned_mediump>::tvec4(float s) :
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD vec<4, float, aligned_mediump>::vec(float s) :
 		data(_mm_set1_ps(s))
 	{}
 
-	template <>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD tvec4<float, aligned_highp>::tvec4(float s) :
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD vec<4, float, aligned_highp>::vec(float s) :
 		data(_mm_set1_ps(s))
 	{}
 
 #	if GLM_ARCH & GLM_ARCH_AVX_BIT
-	template <>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD tvec4<double, aligned_lowp>::tvec4(double s) :
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD vec<4, double, aligned_lowp>::vec(double s) :
 		data(_mm256_set1_pd(s))
 	{}
 
-	template <>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD tvec4<double, aligned_mediump>::tvec4(double s) :
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD vec<4, double, aligned_mediump>::vec(double s) :
 		data(_mm256_set1_pd(s))
 	{}
 
-	template <>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD tvec4<double, aligned_highp>::tvec4(double s) :
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD vec<4, double, aligned_highp>::vec(double s) :
 		data(_mm256_set1_pd(s))
 	{}
 #	endif
 
-	template <>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD tvec4<int32, aligned_lowp>::tvec4(int32 s) :
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD vec<4, int32, aligned_lowp>::vec(int32 s) :
 		data(_mm_set1_epi32(s))
 	{}
 
-	template <>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD tvec4<int32, aligned_mediump>::tvec4(int32 s) :
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD vec<4, int32, aligned_mediump>::vec(int32 s) :
 		data(_mm_set1_epi32(s))
 	{}
 
-	template <>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD tvec4<int32, aligned_highp>::tvec4(int32 s) :
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD vec<4, int32, aligned_highp>::vec(int32 s) :
 		data(_mm_set1_epi32(s))
 	{}
 
 #	if GLM_ARCH & GLM_ARCH_AVX2_BIT
-	template <>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD tvec4<int64, aligned_lowp>::tvec4(int64 s) :
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD vec<4, int64, aligned_lowp>::vec(int64 s) :
 		data(_mm256_set1_epi64x(s))
 	{}
 
-	template <>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD tvec4<int64, aligned_mediump>::tvec4(int64 s) :
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD vec<4, int64, aligned_mediump>::vec(int64 s) :
 		data(_mm256_set1_epi64x(s))
 	{}
 
-	template <>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD tvec4<int64, aligned_highp>::tvec4(int64 s) :
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD vec<4, int64, aligned_highp>::vec(int64 s) :
 		data(_mm256_set1_epi64x(s))
 	{}
 #	endif
 
-	template <>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD tvec4<float, aligned_lowp>::tvec4(float a, float b, float c, float d) :
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD vec<4, float, aligned_lowp>::vec(float a, float b, float c, float d) :
 		data(_mm_set_ps(d, c, b, a))
 	{}
 
-	template <>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD tvec4<float, aligned_mediump>::tvec4(float a, float b, float c, float d) :
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD vec<4, float, aligned_mediump>::vec(float a, float b, float c, float d) :
 		data(_mm_set_ps(d, c, b, a))
 	{}
 
-	template <>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD tvec4<float, aligned_highp>::tvec4(float a, float b, float c, float d) :
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD vec<4, float, aligned_highp>::vec(float a, float b, float c, float d) :
 		data(_mm_set_ps(d, c, b, a))
 	{}
 
-	template <>
-	template <>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD tvec4<int32, aligned_lowp>::tvec4(int32 a, int32 b, int32 c, int32 d) :
+	template<>
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD vec<4, int32, aligned_lowp>::vec(int32 a, int32 b, int32 c, int32 d) :
 		data(_mm_set_epi32(d, c, b, a))
 	{}
 
-	template <>
-	template <>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD tvec4<int32, aligned_mediump>::tvec4(int32 a, int32 b, int32 c, int32 d) :
+	template<>
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD vec<4, int32, aligned_mediump>::vec(int32 a, int32 b, int32 c, int32 d) :
 		data(_mm_set_epi32(d, c, b, a))
 	{}
 
-	template <>
-	template <>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD tvec4<int32, aligned_highp>::tvec4(int32 a, int32 b, int32 c, int32 d) :
+	template<>
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD vec<4, int32, aligned_highp>::vec(int32 a, int32 b, int32 c, int32 d) :
 		data(_mm_set_epi32(d, c, b, a))
 	{}
 
-	template <>
-	template <>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD tvec4<float, aligned_lowp>::tvec4(int32 a, int32 b, int32 c, int32 d) :
+	template<>
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD vec<4, float, aligned_lowp>::vec(int32 a, int32 b, int32 c, int32 d) :
 		data(_mm_castsi128_ps(_mm_set_epi32(d, c, b, a)))
 	{}
 
-	template <>
-	template <>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD tvec4<float, aligned_mediump>::tvec4(int32 a, int32 b, int32 c, int32 d) :
+	template<>
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD vec<4, float, aligned_mediump>::vec(int32 a, int32 b, int32 c, int32 d) :
 		data(_mm_castsi128_ps(_mm_set_epi32(d, c, b, a)))
 	{}
 
-	template <>
-	template <>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD tvec4<float, aligned_highp>::tvec4(int32 a, int32 b, int32 c, int32 d) :
+	template<>
+	template<>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD vec<4, float, aligned_highp>::vec(int32 a, int32 b, int32 c, int32 d) :
 		data(_mm_castsi128_ps(_mm_set_epi32(d, c, b, a)))
 	{}
 }//namespace glm
diff --git a/glm/fwd.hpp b/glm/fwd.hpp
index f90c4d04..04c7c5a7 100644
--- a/glm/fwd.hpp
+++ b/glm/fwd.hpp
@@ -12,7 +12,7 @@
 // GLM_GTC_quaternion
 namespace glm
 {
-	template <typename T, precision P> struct tquat;
+	template<typename T, precision P> struct tquat;
 
 	/// Quaternion of low single-precision floating-point numbers.
 	///
@@ -300,53 +300,53 @@ namespace glm
 	
 	/// Low precision 8 bit signed integer scalar type.
 	/// @see gtc_type_precision
-	typedef tvec1<i8, lowp> lowp_i8vec1;
+	typedef vec<1, i8, lowp> lowp_i8vec1;
 	
 	/// Low precision 8 bit signed integer vector of 2 components type.
 	/// @see gtc_type_precision
-	typedef tvec2<i8, lowp> lowp_i8vec2;
+	typedef vec<2, i8, lowp> lowp_i8vec2;
 	
 	/// Low precision 8 bit signed integer vector of 3 components type.
 	/// @see gtc_type_precision
-	typedef tvec3<i8, lowp> lowp_i8vec3;
+	typedef vec<3, i8, lowp> lowp_i8vec3;
 	
 	/// Low precision 8 bit signed integer vector of 4 components type.
 	/// @see gtc_type_precision
-	typedef tvec4<i8, lowp> lowp_i8vec4;
+	typedef vec<4, i8, lowp> lowp_i8vec4;
 	
 
 	/// Medium precision 8 bit signed integer scalar type.
 	/// @see gtc_type_precision
-	typedef tvec1<i8, mediump> mediump_i8vec1;
+	typedef vec<1, i8, mediump> mediump_i8vec1;
 	
 	/// Medium precision 8 bit signed integer vector of 2 components type.
 	/// @see gtc_type_precision
-	typedef tvec2<i8, mediump> mediump_i8vec2;
+	typedef vec<2, i8, mediump> mediump_i8vec2;
 	
 	/// Medium precision 8 bit signed integer vector of 3 components type.
 	/// @see gtc_type_precision
-	typedef tvec3<i8, mediump> mediump_i8vec3;
+	typedef vec<3, i8, mediump> mediump_i8vec3;
 	
 	/// Medium precision 8 bit signed integer vector of 4 components type.
 	/// @see gtc_type_precision
-	typedef tvec4<i8, mediump> mediump_i8vec4;
+	typedef vec<4, i8, mediump> mediump_i8vec4;
 	
 	
 	/// High precision 8 bit signed integer scalar type.
 	/// @see gtc_type_precision
-	typedef tvec1<i8, highp> highp_i8vec1;
+	typedef vec<1, i8, highp> highp_i8vec1;
 	
 	/// High precision 8 bit signed integer vector of 2 components type.
 	/// @see gtc_type_precision
-	typedef tvec2<i8, highp> highp_i8vec2;
+	typedef vec<2, i8, highp> highp_i8vec2;
 	
 	/// High precision 8 bit signed integer vector of 3 components type.
 	/// @see gtc_type_precision
-	typedef tvec3<i8, highp> highp_i8vec3;
+	typedef vec<3, i8, highp> highp_i8vec3;
 	
 	/// High precision 8 bit signed integer vector of 4 components type.
 	/// @see gtc_type_precision
-	typedef tvec4<i8, highp> highp_i8vec4;
+	typedef vec<4, i8, highp> highp_i8vec4;
 	
 #if(defined(GLM_PRECISION_LOWP_INT))
 	typedef lowp_i8vec1				i8vec1;
@@ -379,53 +379,53 @@ namespace glm
 	
 	/// Low precision 16 bit signed integer scalar type.
 	/// @see gtc_type_precision
-	typedef tvec1<i16, lowp>		lowp_i16vec1;
+	typedef vec<1, i16, lowp>		lowp_i16vec1;
 	
 	/// Low precision 16 bit signed integer vector of 2 components type.
 	/// @see gtc_type_precision
-	typedef tvec2<i16, lowp>		lowp_i16vec2;
+	typedef vec<2, i16, lowp>		lowp_i16vec2;
 	
 	/// Low precision 16 bit signed integer vector of 3 components type.
 	/// @see gtc_type_precision
-	typedef tvec3<i16, lowp>		lowp_i16vec3;
+	typedef vec<3, i16, lowp>		lowp_i16vec3;
 	
 	/// Low precision 16 bit signed integer vector of 4 components type.
 	/// @see gtc_type_precision
-	typedef tvec4<i16, lowp>		lowp_i16vec4;
+	typedef vec<4, i16, lowp>		lowp_i16vec4;
 	
 	
 	/// Medium precision 16 bit signed integer scalar type.
 	/// @see gtc_type_precision
-	typedef tvec1<i16, mediump>		mediump_i16vec1;
+	typedef vec<1, i16, mediump>		mediump_i16vec1;
 	
 	/// Medium precision 16 bit signed integer vector of 2 components type.
 	/// @see gtc_type_precision
-	typedef tvec2<i16, mediump>		mediump_i16vec2;
+	typedef vec<2, i16, mediump>		mediump_i16vec2;
 	
 	/// Medium precision 16 bit signed integer vector of 3 components type.
 	/// @see gtc_type_precision
-	typedef tvec3<i16, mediump>		mediump_i16vec3;
+	typedef vec<3, i16, mediump>		mediump_i16vec3;
 	
 	/// Medium precision 16 bit signed integer vector of 4 components type.
 	/// @see gtc_type_precision
-	typedef tvec4<i16, mediump>		mediump_i16vec4;
+	typedef vec<4, i16, mediump>		mediump_i16vec4;
 	
 	
 	/// High precision 16 bit signed integer scalar type.
 	/// @see gtc_type_precision
-	typedef tvec1<i16, highp>		highp_i16vec1;
+	typedef vec<1, i16, highp>		highp_i16vec1;
 	
 	/// High precision 16 bit signed integer vector of 2 components type.
 	/// @see gtc_type_precision
-	typedef tvec2<i16, highp>		highp_i16vec2;
+	typedef vec<2, i16, highp>		highp_i16vec2;
 	
 	/// High precision 16 bit signed integer vector of 3 components type.
 	/// @see gtc_type_precision
-	typedef tvec3<i16, highp>		highp_i16vec3;
+	typedef vec<3, i16, highp>		highp_i16vec3;
 	
 	/// High precision 16 bit signed integer vector of 4 components type.
 	/// @see gtc_type_precision
-	typedef tvec4<i16, highp>		highp_i16vec4;
+	typedef vec<4, i16, highp>		highp_i16vec4;
 	
 	
 #if(defined(GLM_PRECISION_LOWP_INT))
@@ -459,53 +459,53 @@ namespace glm
 
 	/// Low precision 32 bit signed integer scalar type.
 	/// @see gtc_type_precision
-	typedef tvec1<i32, lowp>		lowp_i32vec1;
+	typedef vec<1, i32, lowp>		lowp_i32vec1;
 	
 	/// Low precision 32 bit signed integer vector of 2 components type.
 	/// @see gtc_type_precision
-	typedef tvec2<i32, lowp>		lowp_i32vec2;
+	typedef vec<2, i32, lowp>		lowp_i32vec2;
 	
 	/// Low precision 32 bit signed integer vector of 3 components type.
 	/// @see gtc_type_precision
-	typedef tvec3<i32, lowp>		lowp_i32vec3;
+	typedef vec<3, i32, lowp>		lowp_i32vec3;
 	
 	/// Low precision 32 bit signed integer vector of 4 components type.
 	/// @see gtc_type_precision
-	typedef tvec4<i32, lowp>		lowp_i32vec4;
+	typedef vec<4, i32, lowp>		lowp_i32vec4;
 	
 	
 	/// Medium precision 32 bit signed integer scalar type.
 	/// @see gtc_type_precision
-	typedef tvec1<i32, mediump>		mediump_i32vec1;
+	typedef vec<1, i32, mediump>		mediump_i32vec1;
 	
 	/// Medium precision 32 bit signed integer vector of 2 components type.
 	/// @see gtc_type_precision
-	typedef tvec2<i32, mediump>		mediump_i32vec2;
+	typedef vec<2, i32, mediump>		mediump_i32vec2;
 	
 	/// Medium precision 32 bit signed integer vector of 3 components type.
 	/// @see gtc_type_precision
-	typedef tvec3<i32, mediump>		mediump_i32vec3;
+	typedef vec<3, i32, mediump>		mediump_i32vec3;
 	
 	/// Medium precision 32 bit signed integer vector of 4 components type.
 	/// @see gtc_type_precision
-	typedef tvec4<i32, mediump>		mediump_i32vec4;
+	typedef vec<4, i32, mediump>		mediump_i32vec4;
 	
 	
 	/// High precision 32 bit signed integer scalar type.
 	/// @see gtc_type_precision
-	typedef tvec1<i32, highp>		highp_i32vec1;
+	typedef vec<1, i32, highp>		highp_i32vec1;
 	
 	/// High precision 32 bit signed integer vector of 2 components type.
 	/// @see gtc_type_precision
-	typedef tvec2<i32, highp>		highp_i32vec2;
+	typedef vec<2, i32, highp>		highp_i32vec2;
 	
 	/// High precision 32 bit signed integer vector of 3 components type.
 	/// @see gtc_type_precision
-	typedef tvec3<i32, highp>		highp_i32vec3;
+	typedef vec<3, i32, highp>		highp_i32vec3;
 	
 	/// High precision 32 bit signed integer vector of 4 components type.
 	/// @see gtc_type_precision
-	typedef tvec4<i32, highp>		highp_i32vec4;
+	typedef vec<4, i32, highp>		highp_i32vec4;
 	
 #if(defined(GLM_PRECISION_LOWP_INT))
 	typedef lowp_i32vec1			i32vec1;
@@ -538,53 +538,53 @@ namespace glm
 
 	/// Low precision 32 bit signed integer scalar type.
 	/// @see gtc_type_precision
-	typedef tvec1<i32, lowp>		lowp_i32vec1;
+	typedef vec<1, i32, lowp>		lowp_i32vec1;
 	
 	/// Low precision 32 bit signed integer vector of 2 components type.
 	/// @see gtc_type_precision
-	typedef tvec2<i32, lowp>		lowp_i32vec2;
+	typedef vec<2, i32, lowp>		lowp_i32vec2;
 	
 	/// Low precision 32 bit signed integer vector of 3 components type.
 	/// @see gtc_type_precision
-	typedef tvec3<i32, lowp>		lowp_i32vec3;
+	typedef vec<3, i32, lowp>		lowp_i32vec3;
 	
 	/// Low precision 32 bit signed integer vector of 4 components type.
 	/// @see gtc_type_precision
-	typedef tvec4<i32, lowp>		lowp_i32vec4;
+	typedef vec<4, i32, lowp>		lowp_i32vec4;
 	
 	
 	/// Medium precision 32 bit signed integer scalar type.
 	/// @see gtc_type_precision
-	typedef tvec1<i32, mediump>		mediump_i32vec1;
+	typedef vec<1, i32, mediump>		mediump_i32vec1;
 	
 	/// Medium precision 32 bit signed integer vector of 2 components type.
 	/// @see gtc_type_precision
-	typedef tvec2<i32, mediump>		mediump_i32vec2;
+	typedef vec<2, i32, mediump>		mediump_i32vec2;
 	
 	/// Medium precision 32 bit signed integer vector of 3 components type.
 	/// @see gtc_type_precision
-	typedef tvec3<i32, mediump>		mediump_i32vec3;
+	typedef vec<3, i32, mediump>		mediump_i32vec3;
 	
 	/// Medium precision 32 bit signed integer vector of 4 components type.
 	/// @see gtc_type_precision
-	typedef tvec4<i32, mediump>		mediump_i32vec4;
+	typedef vec<4, i32, mediump>		mediump_i32vec4;
 	
 	
 	/// High precision 32 bit signed integer scalar type.
 	/// @see gtc_type_precision
-	typedef tvec1<i32, highp>		highp_i32vec1;
+	typedef vec<1, i32, highp>		highp_i32vec1;
 	
 	/// High precision 32 bit signed integer vector of 2 components type.
 	/// @see gtc_type_precision
-	typedef tvec2<i32, highp>		highp_i32vec2;
+	typedef vec<2, i32, highp>		highp_i32vec2;
 	
 	/// High precision 32 bit signed integer vector of 3 components type.
 	/// @see gtc_type_precision
-	typedef tvec3<i32, highp>		highp_i32vec3;
+	typedef vec<3, i32, highp>		highp_i32vec3;
 	
 	/// High precision 32 bit signed integer vector of 4 components type.
 	/// @see gtc_type_precision
-	typedef tvec4<i32, highp>		highp_i32vec4;
+	typedef vec<4, i32, highp>		highp_i32vec4;
 	
 #if(defined(GLM_PRECISION_LOWP_INT))
 	typedef lowp_i32vec1			i32vec1;
@@ -618,53 +618,53 @@ namespace glm
 	
 	/// Low precision 64 bit signed integer scalar type.
 	/// @see gtc_type_precision
-	typedef tvec1<i64, lowp>		lowp_i64vec1;
+	typedef vec<1, i64, lowp>		lowp_i64vec1;
 	
 	/// Low precision 64 bit signed integer vector of 2 components type.
 	/// @see gtc_type_precision
-	typedef tvec2<i64, lowp>		lowp_i64vec2;
+	typedef vec<2, i64, lowp>		lowp_i64vec2;
 	
 	/// Low precision 64 bit signed integer vector of 3 components type.
 	/// @see gtc_type_precision
-	typedef tvec3<i64, lowp>		lowp_i64vec3;
+	typedef vec<3, i64, lowp>		lowp_i64vec3;
 	
 	/// Low precision 64 bit signed integer vector of 4 components type.
 	/// @see gtc_type_precision
-	typedef tvec4<i64, lowp>		lowp_i64vec4;
+	typedef vec<4, i64, lowp>		lowp_i64vec4;
 	
 	
 	/// Medium precision 64 bit signed integer scalar type.
 	/// @see gtc_type_precision
-	typedef tvec1<i64, mediump>		mediump_i64vec1;
+	typedef vec<1, i64, mediump>		mediump_i64vec1;
 	
 	/// Medium precision 64 bit signed integer vector of 2 components type.
 	/// @see gtc_type_precision
-	typedef tvec2<i64, mediump>		mediump_i64vec2;
+	typedef vec<2, i64, mediump>		mediump_i64vec2;
 	
 	/// Medium precision 64 bit signed integer vector of 3 components type.
 	/// @see gtc_type_precision
-	typedef tvec3<i64, mediump>		mediump_i64vec3;
+	typedef vec<3, i64, mediump>		mediump_i64vec3;
 	
 	/// Medium precision 64 bit signed integer vector of 4 components type.
 	/// @see gtc_type_precision
-	typedef tvec4<i64, mediump>		mediump_i64vec4;
+	typedef vec<4, i64, mediump>		mediump_i64vec4;
 	
 	
 	/// High precision 64 bit signed integer scalar type.
 	/// @see gtc_type_precision
-	typedef tvec1<i64, highp>		highp_i64vec1;
+	typedef vec<1, i64, highp>		highp_i64vec1;
 	
 	/// High precision 64 bit signed integer vector of 2 components type.
 	/// @see gtc_type_precision
-	typedef tvec2<i64, highp>		highp_i64vec2;
+	typedef vec<2, i64, highp>		highp_i64vec2;
 	
 	/// High precision 64 bit signed integer vector of 3 components type.
 	/// @see gtc_type_precision
-	typedef tvec3<i64, highp>		highp_i64vec3;
+	typedef vec<3, i64, highp>		highp_i64vec3;
 	
 	/// High precision 64 bit signed integer vector of 4 components type.
 	/// @see gtc_type_precision
-	typedef tvec4<i64, highp>		highp_i64vec4;
+	typedef vec<4, i64, highp>		highp_i64vec4;
 	
 #if(defined(GLM_PRECISION_LOWP_INT))
 	typedef lowp_i64vec1			i64vec1;
@@ -909,53 +909,53 @@ namespace glm
 
 	/// Low precision 8 bit unsigned integer scalar type.
 	/// @see gtc_type_precision
-	typedef tvec1<u8, lowp> lowp_u8vec1;
+	typedef vec<1, u8, lowp> lowp_u8vec1;
 	
 	/// Low precision 8 bit unsigned integer vector of 2 components type.
 	/// @see gtc_type_precision
-	typedef tvec2<u8, lowp> lowp_u8vec2;
+	typedef vec<2, u8, lowp> lowp_u8vec2;
 	
 	/// Low precision 8 bit unsigned integer vector of 3 components type.
 	/// @see gtc_type_precision
-	typedef tvec3<u8, lowp> lowp_u8vec3;
+	typedef vec<3, u8, lowp> lowp_u8vec3;
 	
 	/// Low precision 8 bit unsigned integer vector of 4 components type.
 	/// @see gtc_type_precision
-	typedef tvec4<u8, lowp> lowp_u8vec4;
+	typedef vec<4, u8, lowp> lowp_u8vec4;
 	
 
 	/// Medium precision 8 bit unsigned integer scalar type.
 	/// @see gtc_type_precision
-	typedef tvec1<u8, mediump> mediump_u8vec1;
+	typedef vec<1, u8, mediump> mediump_u8vec1;
 
 	/// Medium precision 8 bit unsigned integer vector of 2 components type.
 	/// @see gtc_type_precision
-	typedef tvec2<u8, mediump> mediump_u8vec2;
+	typedef vec<2, u8, mediump> mediump_u8vec2;
 
 	/// Medium precision 8 bit unsigned integer vector of 3 components type.
 	/// @see gtc_type_precision
-	typedef tvec3<u8, mediump> mediump_u8vec3;
+	typedef vec<3, u8, mediump> mediump_u8vec3;
 
 	/// Medium precision 8 bit unsigned integer vector of 4 components type.
 	/// @see gtc_type_precision
-	typedef tvec4<u8, mediump> mediump_u8vec4;
+	typedef vec<4, u8, mediump> mediump_u8vec4;
 
 
 	/// High precision 8 bit unsigned integer scalar type.
 	/// @see gtc_type_precision
-	typedef tvec1<u8, highp> highp_u8vec1;
+	typedef vec<1, u8, highp> highp_u8vec1;
 
 	/// High precision 8 bit unsigned integer vector of 2 components type.
 	/// @see gtc_type_precision
-	typedef tvec2<u8, highp> highp_u8vec2;
+	typedef vec<2, u8, highp> highp_u8vec2;
 
 	/// High precision 8 bit unsigned integer vector of 3 components type.
 	/// @see gtc_type_precision
-	typedef tvec3<u8, highp> highp_u8vec3;
+	typedef vec<3, u8, highp> highp_u8vec3;
 
 	/// High precision 8 bit unsigned integer vector of 4 components type.
 	/// @see gtc_type_precision
-	typedef tvec4<u8, highp> highp_u8vec4;
+	typedef vec<4, u8, highp> highp_u8vec4;
 
 #if(defined(GLM_PRECISION_LOWP_INT))
 	typedef lowp_u8vec1				u8vec1;
@@ -988,53 +988,53 @@ namespace glm
 
 	/// Low precision 16 bit unsigned integer scalar type.
 	/// @see gtc_type_precision
-	typedef tvec1<u16, lowp>		lowp_u16vec1;
+	typedef vec<1, u16, lowp>		lowp_u16vec1;
 
 	/// Low precision 16 bit unsigned integer vector of 2 components type.
 	/// @see gtc_type_precision
-	typedef tvec2<u16, lowp>		lowp_u16vec2;
+	typedef vec<2, u16, lowp>		lowp_u16vec2;
 
 	/// Low precision 16 bit unsigned integer vector of 3 components type.
 	/// @see gtc_type_precision
-	typedef tvec3<u16, lowp>		lowp_u16vec3;
+	typedef vec<3, u16, lowp>		lowp_u16vec3;
 
 	/// Low precision 16 bit unsigned integer vector of 4 components type.
 	/// @see gtc_type_precision
-	typedef tvec4<u16, lowp>		lowp_u16vec4;
+	typedef vec<4, u16, lowp>		lowp_u16vec4;
 
 
 	/// Medium precision 16 bit unsigned integer scalar type.
 	/// @see gtc_type_precision
-	typedef tvec1<u16, mediump>		mediump_u16vec1;
+	typedef vec<1, u16, mediump>		mediump_u16vec1;
 
 	/// Medium precision 16 bit unsigned integer vector of 2 components type.
 	/// @see gtc_type_precision
-	typedef tvec2<u16, mediump>		mediump_u16vec2;
+	typedef vec<2, u16, mediump>		mediump_u16vec2;
 
 	/// Medium precision 16 bit unsigned integer vector of 3 components type.
 	/// @see gtc_type_precision
-	typedef tvec3<u16, mediump>		mediump_u16vec3;
+	typedef vec<3, u16, mediump>		mediump_u16vec3;
 
 	/// Medium precision 16 bit unsigned integer vector of 4 components type.
 	/// @see gtc_type_precision
-	typedef tvec4<u16, mediump>		mediump_u16vec4;
+	typedef vec<4, u16, mediump>		mediump_u16vec4;
 
 
 	/// High precision 16 bit unsigned integer scalar type.
 	/// @see gtc_type_precision
-	typedef tvec1<u16, highp>		highp_u16vec1;
+	typedef vec<1, u16, highp>		highp_u16vec1;
 
 	/// High precision 16 bit unsigned integer vector of 2 components type.
 	/// @see gtc_type_precision
-	typedef tvec2<u16, highp>		highp_u16vec2;
+	typedef vec<2, u16, highp>		highp_u16vec2;
 
 	/// High precision 16 bit unsigned integer vector of 3 components type.
 	/// @see gtc_type_precision
-	typedef tvec3<u16, highp>		highp_u16vec3;
+	typedef vec<3, u16, highp>		highp_u16vec3;
 
 	/// High precision 16 bit unsigned integer vector of 4 components type.
 	/// @see gtc_type_precision
-	typedef tvec4<u16, highp>		highp_u16vec4;
+	typedef vec<4, u16, highp>		highp_u16vec4;
 
 
 #if(defined(GLM_PRECISION_LOWP_INT))
@@ -1068,53 +1068,53 @@ namespace glm
 
 	/// Low precision 32 bit unsigned integer scalar type.
 	/// @see gtc_type_precision
-	typedef tvec1<u32, lowp>		lowp_u32vec1;
+	typedef vec<1, u32, lowp>		lowp_u32vec1;
 
 	/// Low precision 32 bit unsigned integer vector of 2 components type.
 	/// @see gtc_type_precision
-	typedef tvec2<u32, lowp>		lowp_u32vec2;
+	typedef vec<2, u32, lowp>		lowp_u32vec2;
 
 	/// Low precision 32 bit unsigned integer vector of 3 components type.
 	/// @see gtc_type_precision
-	typedef tvec3<u32, lowp>		lowp_u32vec3;
+	typedef vec<3, u32, lowp>		lowp_u32vec3;
 
 	/// Low precision 32 bit unsigned integer vector of 4 components type.
 	/// @see gtc_type_precision
-	typedef tvec4<u32, lowp>		lowp_u32vec4;
+	typedef vec<4, u32, lowp>		lowp_u32vec4;
 
 
 	/// Medium precision 32 bit unsigned integer scalar type.
 	/// @see gtc_type_precision
-	typedef tvec1<u32, mediump>		mediump_u32vec1;
+	typedef vec<1, u32, mediump>		mediump_u32vec1;
 
 	/// Medium precision 32 bit unsigned integer vector of 2 components type.
 	/// @see gtc_type_precision
-	typedef tvec2<u32, mediump>		mediump_u32vec2;
+	typedef vec<2, u32, mediump>		mediump_u32vec2;
 
 	/// Medium precision 32 bit unsigned integer vector of 3 components type.
 	/// @see gtc_type_precision
-	typedef tvec3<u32, mediump>		mediump_u32vec3;
+	typedef vec<3, u32, mediump>		mediump_u32vec3;
 
 	/// Medium precision 32 bit unsigned integer vector of 4 components type.
 	/// @see gtc_type_precision
-	typedef tvec4<u32, mediump>		mediump_u32vec4;
+	typedef vec<4, u32, mediump>		mediump_u32vec4;
 
 
 	/// High precision 32 bit unsigned integer scalar type.
 	/// @see gtc_type_precision
-	typedef tvec1<u32, highp>		highp_u32vec1;
+	typedef vec<1, u32, highp>		highp_u32vec1;
 
 	/// High precision 32 bit unsigned integer vector of 2 components type.
 	/// @see gtc_type_precision
-	typedef tvec2<u32, highp>		highp_u32vec2;
+	typedef vec<2, u32, highp>		highp_u32vec2;
 
 	/// High precision 32 bit unsigned integer vector of 3 components type.
 	/// @see gtc_type_precision
-	typedef tvec3<u32, highp>		highp_u32vec3;
+	typedef vec<3, u32, highp>		highp_u32vec3;
 
 	/// High precision 32 bit unsigned integer vector of 4 components type.
 	/// @see gtc_type_precision
-	typedef tvec4<u32, highp>		highp_u32vec4;
+	typedef vec<4, u32, highp>		highp_u32vec4;
 
 #if(defined(GLM_PRECISION_LOWP_INT))
 	typedef lowp_u32vec1			u32vec1;
@@ -1147,53 +1147,53 @@ namespace glm
 
 	/// Low precision 32 bit unsigned integer scalar type.
 	/// @see gtc_type_precision
-	typedef tvec1<u32, lowp>		lowp_u32vec1;
+	typedef vec<1, u32, lowp>		lowp_u32vec1;
 
 	/// Low precision 32 bit unsigned integer vector of 2 components type.
 	/// @see gtc_type_precision
-	typedef tvec2<u32, lowp>		lowp_u32vec2;
+	typedef vec<2, u32, lowp>		lowp_u32vec2;
 
 	/// Low precision 32 bit unsigned integer vector of 3 components type.
 	/// @see gtc_type_precision
-	typedef tvec3<u32, lowp>		lowp_u32vec3;
+	typedef vec<3, u32, lowp>		lowp_u32vec3;
 
 	/// Low precision 32 bit unsigned integer vector of 4 components type.
 	/// @see gtc_type_precision
-	typedef tvec4<u32, lowp>		lowp_u32vec4;
+	typedef vec<4, u32, lowp>		lowp_u32vec4;
 
 
 	/// Medium precision 32 bit unsigned integer scalar type.
 	/// @see gtc_type_precision
-	typedef tvec1<u32, mediump>		mediump_u32vec1;
+	typedef vec<1, u32, mediump>		mediump_u32vec1;
 
 	/// Medium precision 32 bit unsigned integer vector of 2 components type.
 	/// @see gtc_type_precision
-	typedef tvec2<u32, mediump>		mediump_u32vec2;
+	typedef vec<2, u32, mediump>		mediump_u32vec2;
 
 	/// Medium precision 32 bit unsigned integer vector of 3 components type.
 	/// @see gtc_type_precision
-	typedef tvec3<u32, mediump>		mediump_u32vec3;
+	typedef vec<3, u32, mediump>		mediump_u32vec3;
 
 	/// Medium precision 32 bit unsigned integer vector of 4 components type.
 	/// @see gtc_type_precision
-	typedef tvec4<u32, mediump>		mediump_u32vec4;
+	typedef vec<4, u32, mediump>		mediump_u32vec4;
 
 
 	/// High precision 32 bit unsigned integer scalar type.
 	/// @see gtc_type_precision
-	typedef tvec1<u32, highp>		highp_u32vec1;
+	typedef vec<1, u32, highp>		highp_u32vec1;
 
 	/// High precision 32 bit unsigned integer vector of 2 components type.
 	/// @see gtc_type_precision
-	typedef tvec2<u32, highp>		highp_u32vec2;
+	typedef vec<2, u32, highp>		highp_u32vec2;
 
 	/// High precision 32 bit unsigned integer vector of 3 components type.
 	/// @see gtc_type_precision
-	typedef tvec3<u32, highp>		highp_u32vec3;
+	typedef vec<3, u32, highp>		highp_u32vec3;
 
 	/// High precision 32 bit unsigned integer vector of 4 components type.
 	/// @see gtc_type_precision
-	typedef tvec4<u32, highp>		highp_u32vec4;
+	typedef vec<4, u32, highp>		highp_u32vec4;
 
 #if(defined(GLM_PRECISION_LOWP_INT))
 	typedef lowp_u32vec1			u32vec1;
@@ -1227,53 +1227,53 @@ namespace glm
 	
 	/// Low precision 64 bit unsigned integer scalar type.
 	/// @see gtc_type_precision
-	typedef tvec1<u64, lowp>		lowp_u64vec1;
+	typedef vec<1, u64, lowp>		lowp_u64vec1;
 
 	/// Low precision 64 bit unsigned integer vector of 2 components type.
 	/// @see gtc_type_precision
-	typedef tvec2<u64, lowp>		lowp_u64vec2;
+	typedef vec<2, u64, lowp>		lowp_u64vec2;
 
 	/// Low precision 64 bit unsigned integer vector of 3 components type.
 	/// @see gtc_type_precision
-	typedef tvec3<u64, lowp>		lowp_u64vec3;
+	typedef vec<3, u64, lowp>		lowp_u64vec3;
 
 	/// Low precision 64 bit unsigned integer vector of 4 components type.
 	/// @see gtc_type_precision
-	typedef tvec4<u64, lowp>		lowp_u64vec4;
+	typedef vec<4, u64, lowp>		lowp_u64vec4;
 
 
 	/// Medium precision 64 bit unsigned integer scalar type.
 	/// @see gtc_type_precision
-	typedef tvec1<u64, mediump>		mediump_u64vec1;
+	typedef vec<1, u64, mediump>		mediump_u64vec1;
 
 	/// Medium precision 64 bit unsigned integer vector of 2 components type.
 	/// @see gtc_type_precision
-	typedef tvec2<u64, mediump>		mediump_u64vec2;
+	typedef vec<2, u64, mediump>		mediump_u64vec2;
 
 	/// Medium precision 64 bit unsigned integer vector of 3 components type.
 	/// @see gtc_type_precision
-	typedef tvec3<u64, mediump>		mediump_u64vec3;
+	typedef vec<3, u64, mediump>		mediump_u64vec3;
 
 	/// Medium precision 64 bit unsigned integer vector of 4 components type.
 	/// @see gtc_type_precision
-	typedef tvec4<u64, mediump>		mediump_u64vec4;
+	typedef vec<4, u64, mediump>		mediump_u64vec4;
 
 
 	/// High precision 64 bit unsigned integer scalar type.
 	/// @see gtc_type_precision
-	typedef tvec1<u64, highp>		highp_u64vec1;
+	typedef vec<1, u64, highp>		highp_u64vec1;
 
 	/// High precision 64 bit unsigned integer vector of 2 components type.
 	/// @see gtc_type_precision
-	typedef tvec2<u64, highp>		highp_u64vec2;
+	typedef vec<2, u64, highp>		highp_u64vec2;
 
 	/// High precision 64 bit unsigned integer vector of 3 components type.
 	/// @see gtc_type_precision
-	typedef tvec3<u64, highp>		highp_u64vec3;
+	typedef vec<3, u64, highp>		highp_u64vec3;
 
 	/// High precision 64 bit unsigned integer vector of 4 components type.
 	/// @see gtc_type_precision
-	typedef tvec4<u64, highp>		highp_u64vec4;
+	typedef vec<4, u64, highp>		highp_u64vec4;
 
 #if(defined(GLM_PRECISION_LOWP_UINT))
 	typedef lowp_u64vec1			u64vec1;
@@ -1512,199 +1512,199 @@ namespace glm
 
 	/// Low single-precision floating-point vector of 1 component.
 	/// @see gtc_type_precision
-	typedef tvec1<float, lowp> lowp_vec1;
+	typedef vec<1, float, lowp> lowp_vec1;
 
 	/// Low single-precision floating-point vector of 2 components.
 	/// @see core_precision
-	typedef tvec2<float, lowp> lowp_vec2;
+	typedef vec<2, float, lowp> lowp_vec2;
 
 	/// Low single-precision floating-point vector of 3 components.
 	/// @see core_precision
-	typedef tvec3<float, lowp> lowp_vec3;
+	typedef vec<3, float, lowp> lowp_vec3;
 
 	/// Low single-precision floating-point vector of 4 components.
 	/// @see core_precision
-	typedef tvec4<float, lowp> lowp_vec4;
+	typedef vec<4, float, lowp> lowp_vec4;
 
 	/// Low single-precision floating-point vector of 1 component.
 	/// @see gtc_type_precision
-	typedef tvec1<float, lowp> lowp_fvec1;
+	typedef vec<1, float, lowp> lowp_fvec1;
 
 	/// Low single-precision floating-point vector of 2 components.
 	/// @see gtc_type_precision
-	typedef tvec2<float, lowp> lowp_fvec2;
+	typedef vec<2, float, lowp> lowp_fvec2;
 
 	/// Low single-precision floating-point vector of 3 components.
 	/// @see gtc_type_precision
-	typedef tvec3<float, lowp> lowp_fvec3;
+	typedef vec<3, float, lowp> lowp_fvec3;
 
 	/// Low single-precision floating-point vector of 4 components.
 	/// @see gtc_type_precision
-	typedef tvec4<float, lowp> lowp_fvec4;
+	typedef vec<4, float, lowp> lowp_fvec4;
 
 
 	/// Medium single-precision floating-point vector of 1 component.
 	/// @see gtc_type_precision
-	typedef tvec1<float, mediump> mediump_vec1;
+	typedef vec<1, float, mediump> mediump_vec1;
 
 	/// Medium Single-precision floating-point vector of 2 components.
 	/// @see core_precision
-	typedef tvec2<float, mediump> mediump_vec2;
+	typedef vec<2, float, mediump> mediump_vec2;
 
 	/// Medium Single-precision floating-point vector of 3 components.
 	/// @see core_precision
-	typedef tvec3<float, mediump> mediump_vec3;
+	typedef vec<3, float, mediump> mediump_vec3;
 
 	/// Medium Single-precision floating-point vector of 4 components.
 	/// @see core_precision
-	typedef tvec4<float, mediump> mediump_vec4;
+	typedef vec<4, float, mediump> mediump_vec4;
 
 	/// Medium single-precision floating-point vector of 1 component.
 	/// @see gtc_type_precision
-	typedef tvec1<float, mediump> mediump_fvec1;
+	typedef vec<1, float, mediump> mediump_fvec1;
 
 	/// Medium Single-precision floating-point vector of 2 components.
 	/// @see gtc_type_precision
-	typedef tvec2<float, mediump> mediump_fvec2;
+	typedef vec<2, float, mediump> mediump_fvec2;
 
 	/// Medium Single-precision floating-point vector of 3 components.
 	/// @see gtc_type_precision
-	typedef tvec3<float, mediump> mediump_fvec3;
+	typedef vec<3, float, mediump> mediump_fvec3;
 
 	/// Medium Single-precision floating-point vector of 4 components.
 	/// @see gtc_type_precision
-	typedef tvec4<float, mediump> mediump_fvec4;
+	typedef vec<4, float, mediump> mediump_fvec4;
 
 
 	/// High single-precision floating-point vector of 1 component.
 	/// @see gtc_type_precision
-	typedef tvec1<float, highp> highp_vec1;
+	typedef vec<1, float, highp> highp_vec1;
 
 	/// High Single-precision floating-point vector of 2 components.
 	/// @see core_precision
-	typedef tvec2<float, highp> highp_vec2;
+	typedef vec<2, float, highp> highp_vec2;
 
 	/// High Single-precision floating-point vector of 3 components.
 	/// @see core_precision
-	typedef tvec3<float, highp> highp_vec3;
+	typedef vec<3, float, highp> highp_vec3;
 
 	/// High Single-precision floating-point vector of 4 components.
 	/// @see core_precision
-	typedef tvec4<float, highp> highp_vec4;
+	typedef vec<4, float, highp> highp_vec4;
 
 	/// High single-precision floating-point vector of 1 component.
 	/// @see gtc_type_precision
-	typedef tvec1<float, highp> highp_fvec1;
+	typedef vec<1, float, highp> highp_fvec1;
 
 	/// High Single-precision floating-point vector of 2 components.
 	/// @see core_precision
-	typedef tvec2<float, highp> highp_fvec2;
+	typedef vec<2, float, highp> highp_fvec2;
 
 	/// High Single-precision floating-point vector of 3 components.
 	/// @see core_precision
-	typedef tvec3<float, highp> highp_fvec3;
+	typedef vec<3, float, highp> highp_fvec3;
 
 	/// High Single-precision floating-point vector of 4 components.
 	/// @see core_precision
-	typedef tvec4<float, highp> highp_fvec4;
+	typedef vec<4, float, highp> highp_fvec4;
 
 
 	/// Low single-precision floating-point vector of 1 component.
 	/// @see gtc_type_precision
-	typedef tvec1<f32, lowp> lowp_f32vec1;
+	typedef vec<1, f32, lowp> lowp_f32vec1;
 
 	/// Low single-precision floating-point vector of 2 components.
 	/// @see core_precision
-	typedef tvec2<f32, lowp> lowp_f32vec2;
+	typedef vec<2, f32, lowp> lowp_f32vec2;
 
 	/// Low single-precision floating-point vector of 3 components.
 	/// @see core_precision
-	typedef tvec3<f32, lowp> lowp_f32vec3;
+	typedef vec<3, f32, lowp> lowp_f32vec3;
 
 	/// Low single-precision floating-point vector of 4 components.
 	/// @see core_precision
-	typedef tvec4<f32, lowp> lowp_f32vec4;
+	typedef vec<4, f32, lowp> lowp_f32vec4;
 
 	/// Medium single-precision floating-point vector of 1 component.
 	/// @see gtc_type_precision
-	typedef tvec1<f32, mediump> mediump_f32vec1;
+	typedef vec<1, f32, mediump> mediump_f32vec1;
 
 	/// Medium single-precision floating-point vector of 2 components.
 	/// @see core_precision
-	typedef tvec2<f32, mediump> mediump_f32vec2;
+	typedef vec<2, f32, mediump> mediump_f32vec2;
 
 	/// Medium single-precision floating-point vector of 3 components.
 	/// @see core_precision
-	typedef tvec3<f32, mediump> mediump_f32vec3;
+	typedef vec<3, f32, mediump> mediump_f32vec3;
 
 	/// Medium single-precision floating-point vector of 4 components.
 	/// @see core_precision
-	typedef tvec4<f32, mediump> mediump_f32vec4;
+	typedef vec<4, f32, mediump> mediump_f32vec4;
 
 	/// High single-precision floating-point vector of 1 component.
 	/// @see gtc_type_precision
-	typedef tvec1<f32, highp> highp_f32vec1;
+	typedef vec<1, f32, highp> highp_f32vec1;
 
 	/// High single-precision floating-point vector of 2 components.
 	/// @see gtc_type_precision
-	typedef tvec2<f32, highp> highp_f32vec2;
+	typedef vec<2, f32, highp> highp_f32vec2;
 
 	/// High single-precision floating-point vector of 3 components.
 	/// @see gtc_type_precision
-	typedef tvec3<f32, highp> highp_f32vec3;
+	typedef vec<3, f32, highp> highp_f32vec3;
 
 	/// High single-precision floating-point vector of 4 components.
 	/// @see gtc_type_precision
-	typedef tvec4<f32, highp> highp_f32vec4;
+	typedef vec<4, f32, highp> highp_f32vec4;
 
 
 	/// Low double-precision floating-point vector of 1 component.
 	/// @see gtc_type_precision
-	typedef tvec1<f64, lowp> lowp_f64vec1;
+	typedef vec<1, f64, lowp> lowp_f64vec1;
 
 	/// Low double-precision floating-point vector of 2 components.
 	/// @see gtc_type_precision
-	typedef tvec2<f64, lowp> lowp_f64vec2;
+	typedef vec<2, f64, lowp> lowp_f64vec2;
 
 	/// Low double-precision floating-point vector of 3 components.
 	/// @see gtc_type_precision
-	typedef tvec3<f64, lowp> lowp_f64vec3;
+	typedef vec<3, f64, lowp> lowp_f64vec3;
 
 	/// Low double-precision floating-point vector of 4 components.
 	/// @see gtc_type_precision
-	typedef tvec4<f64, lowp> lowp_f64vec4;
+	typedef vec<4, f64, lowp> lowp_f64vec4;
 
 	/// Medium double-precision floating-point vector of 1 component.
 	/// @see gtc_type_precision
-	typedef tvec1<f64, mediump> mediump_f64vec1;
+	typedef vec<1, f64, mediump> mediump_f64vec1;
 
 	/// Medium double-precision floating-point vector of 2 components.
 	/// @see gtc_type_precision
-	typedef tvec2<f64, mediump> mediump_f64vec2;
+	typedef vec<2, f64, mediump> mediump_f64vec2;
 
 	/// Medium double-precision floating-point vector of 3 components.
 	/// @see gtc_type_precision
-	typedef tvec3<f64, mediump> mediump_f64vec3;
+	typedef vec<3, f64, mediump> mediump_f64vec3;
 
 	/// Medium double-precision floating-point vector of 4 components.
 	/// @see gtc_type_precision
-	typedef tvec4<f64, mediump> mediump_f64vec4;
+	typedef vec<4, f64, mediump> mediump_f64vec4;
 
 	/// High double-precision floating-point vector of 1 component.
 	/// @see gtc_type_precision
-	typedef tvec1<f64, highp> highp_f64vec1;
+	typedef vec<1, f64, highp> highp_f64vec1;
 
 	/// High double-precision floating-point vector of 2 components.
 	/// @see gtc_type_precision
-	typedef tvec2<f64, highp> highp_f64vec2;
+	typedef vec<2, f64, highp> highp_f64vec2;
 
 	/// High double-precision floating-point vector of 3 components.
 	/// @see gtc_type_precision
-	typedef tvec3<f64, highp> highp_f64vec3;
+	typedef vec<3, f64, highp> highp_f64vec3;
 
 	/// High double-precision floating-point vector of 4 components.
 	/// @see gtc_type_precision
-	typedef tvec4<f64, highp> highp_f64vec4;
+	typedef vec<4, f64, highp> highp_f64vec4;
 
 
 	//////////////////////
@@ -1716,39 +1716,39 @@ namespace glm
 
 	/// Low single-precision floating-point 2x2 matrix.
 	/// @see gtc_type_precision
-	typedef tmat2x2<f32, lowp> lowp_fmat2x2;
+	typedef mat<2, 2, f32, lowp> lowp_fmat2x2;
 
 	/// Low single-precision floating-point 2x3 matrix.
 	/// @see gtc_type_precision
-	typedef tmat2x3<f32, lowp> lowp_fmat2x3;
+	typedef mat<2, 3, f32, lowp> lowp_fmat2x3;
 
 	/// Low single-precision floating-point 2x4 matrix.
 	/// @see gtc_type_precision
-	typedef tmat2x4<f32, lowp> lowp_fmat2x4;
+	typedef mat<2, 4, f32, lowp> lowp_fmat2x4;
 
 	/// Low single-precision floating-point 3x2 matrix.
 	/// @see gtc_type_precision
-	typedef tmat3x2<f32, lowp> lowp_fmat3x2;
+	typedef mat<3, 2, f32, lowp> lowp_fmat3x2;
 
 	/// Low single-precision floating-point 3x3 matrix.
 	/// @see gtc_type_precision
-	typedef tmat3x3<f32, lowp> lowp_fmat3x3;
+	typedef mat<3, 3, f32, lowp> lowp_fmat3x3;
 
 	/// Low single-precision floating-point 3x4 matrix.
 	/// @see gtc_type_precision
-	typedef tmat3x4<f32, lowp> lowp_fmat3x4;
+	typedef mat<3, 4, f32, lowp> lowp_fmat3x4;
 
 	/// Low single-precision floating-point 4x2 matrix.
 	/// @see gtc_type_precision
-	typedef tmat4x2<f32, lowp> lowp_fmat4x2;
+	typedef mat<4, 2, f32, lowp> lowp_fmat4x2;
 
 	/// Low single-precision floating-point 4x3 matrix.
 	/// @see gtc_type_precision
-	typedef tmat4x3<f32, lowp> lowp_fmat4x3;
+	typedef mat<4, 3, f32, lowp> lowp_fmat4x3;
 
 	/// Low single-precision floating-point 4x4 matrix.
 	/// @see gtc_type_precision
-	typedef tmat4x4<f32, lowp> lowp_fmat4x4;
+	typedef mat<4, 4, f32, lowp> lowp_fmat4x4;
 
 	/// Low single-precision floating-point 1x1 matrix.
 	/// @see gtc_type_precision
@@ -1773,39 +1773,39 @@ namespace glm
 
 	/// Medium single-precision floating-point 2x2 matrix.
 	/// @see gtc_type_precision
-	typedef tmat2x2<f32, mediump> mediump_fmat2x2;
+	typedef mat<2, 2, f32, mediump> mediump_fmat2x2;
 
 	/// Medium single-precision floating-point 2x3 matrix.
 	/// @see gtc_type_precision
-	typedef tmat2x3<f32, mediump> mediump_fmat2x3;
+	typedef mat<2, 3, f32, mediump> mediump_fmat2x3;
 
 	/// Medium single-precision floating-point 2x4 matrix.
 	/// @see gtc_type_precision
-	typedef tmat2x4<f32, mediump> mediump_fmat2x4;
+	typedef mat<2, 4, f32, mediump> mediump_fmat2x4;
 
 	/// Medium single-precision floating-point 3x2 matrix.
 	/// @see gtc_type_precision
-	typedef tmat3x2<f32, mediump> mediump_fmat3x2;
+	typedef mat<3, 2, f32, mediump> mediump_fmat3x2;
 
 	/// Medium single-precision floating-point 3x3 matrix.
 	/// @see gtc_type_precision
-	typedef tmat3x3<f32, mediump> mediump_fmat3x3;
+	typedef mat<3, 3, f32, mediump> mediump_fmat3x3;
 
 	/// Medium single-precision floating-point 3x4 matrix.
 	/// @see gtc_type_precision
-	typedef tmat3x4<f32, mediump> mediump_fmat3x4;
+	typedef mat<3, 4, f32, mediump> mediump_fmat3x4;
 
 	/// Medium single-precision floating-point 4x2 matrix.
 	/// @see gtc_type_precision
-	typedef tmat4x2<f32, mediump> mediump_fmat4x2;
+	typedef mat<4, 2, f32, mediump> mediump_fmat4x2;
 
 	/// Medium single-precision floating-point 4x3 matrix.
 	/// @see gtc_type_precision
-	typedef tmat4x3<f32, mediump> mediump_fmat4x3;
+	typedef mat<4, 3, f32, mediump> mediump_fmat4x3;
 
 	/// Medium single-precision floating-point 4x4 matrix.
 	/// @see gtc_type_precision
-	typedef tmat4x4<f32, mediump> mediump_fmat4x4;
+	typedef mat<4, 4, f32, mediump> mediump_fmat4x4;
 
 	/// Medium single-precision floating-point 1x1 matrix.
 	/// @see gtc_type_precision
@@ -1830,39 +1830,39 @@ namespace glm
 
 	/// High single-precision floating-point 2x2 matrix.
 	/// @see gtc_type_precision
-	typedef tmat2x2<f32, highp> highp_fmat2x2;
+	typedef mat<2, 2, f32, highp> highp_fmat2x2;
 
 	/// High single-precision floating-point 2x3 matrix.
 	/// @see gtc_type_precision
-	typedef tmat2x3<f32, highp> highp_fmat2x3;
+	typedef mat<2, 3, f32, highp> highp_fmat2x3;
 
 	/// High single-precision floating-point 2x4 matrix.
 	/// @see gtc_type_precision
-	typedef tmat2x4<f32, highp> highp_fmat2x4;
+	typedef mat<2, 4, f32, highp> highp_fmat2x4;
 
 	/// High single-precision floating-point 3x2 matrix.
 	/// @see gtc_type_precision
-	typedef tmat3x2<f32, highp> highp_fmat3x2;
+	typedef mat<3, 2, f32, highp> highp_fmat3x2;
 
 	/// High single-precision floating-point 3x3 matrix.
 	/// @see gtc_type_precision
-	typedef tmat3x3<f32, highp> highp_fmat3x3;
+	typedef mat<3, 3, f32, highp> highp_fmat3x3;
 
 	/// High single-precision floating-point 3x4 matrix.
 	/// @see gtc_type_precision
-	typedef tmat3x4<f32, highp> highp_fmat3x4;
+	typedef mat<3, 4, f32, highp> highp_fmat3x4;
 
 	/// High single-precision floating-point 4x2 matrix.
 	/// @see gtc_type_precision
-	typedef tmat4x2<f32, highp> highp_fmat4x2;
+	typedef mat<4, 2, f32, highp> highp_fmat4x2;
 
 	/// High single-precision floating-point 4x3 matrix.
 	/// @see gtc_type_precision
-	typedef tmat4x3<f32, highp> highp_fmat4x3;
+	typedef mat<4, 3, f32, highp> highp_fmat4x3;
 
 	/// High single-precision floating-point 4x4 matrix.
 	/// @see gtc_type_precision
-	typedef tmat4x4<f32, highp> highp_fmat4x4;
+	typedef mat<4, 4, f32, highp> highp_fmat4x4;
 
 	/// High single-precision floating-point 1x1 matrix.
 	/// @see gtc_type_precision
@@ -1887,39 +1887,39 @@ namespace glm
 
 	/// Low single-precision floating-point 2x2 matrix.
 	/// @see gtc_type_precision
-	typedef tmat2x2<f32, lowp> lowp_f32mat2x2;
+	typedef mat<2, 2, f32, lowp> lowp_f32mat2x2;
 
 	/// Low single-precision floating-point 2x3 matrix.
 	/// @see gtc_type_precision
-	typedef tmat2x3<f32, lowp> lowp_f32mat2x3;
+	typedef mat<2, 3, f32, lowp> lowp_f32mat2x3;
 
 	/// Low single-precision floating-point 2x4 matrix.
 	/// @see gtc_type_precision
-	typedef tmat2x4<f32, lowp> lowp_f32mat2x4;
+	typedef mat<2, 4, f32, lowp> lowp_f32mat2x4;
 
 	/// Low single-precision floating-point 3x2 matrix.
 	/// @see gtc_type_precision
-	typedef tmat3x2<f32, lowp> lowp_f32mat3x2;
+	typedef mat<3, 2, f32, lowp> lowp_f32mat3x2;
 
 	/// Low single-precision floating-point 3x3 matrix.
 	/// @see gtc_type_precision
-	typedef tmat3x3<f32, lowp> lowp_f32mat3x3;
+	typedef mat<3, 3, f32, lowp> lowp_f32mat3x3;
 
 	/// Low single-precision floating-point 3x4 matrix.
 	/// @see gtc_type_precision
-	typedef tmat3x4<f32, lowp> lowp_f32mat3x4;
+	typedef mat<3, 4, f32, lowp> lowp_f32mat3x4;
 
 	/// Low single-precision floating-point 4x2 matrix.
 	/// @see gtc_type_precision
-	typedef tmat4x2<f32, lowp> lowp_f32mat4x2;
+	typedef mat<4, 2, f32, lowp> lowp_f32mat4x2;
 
 	/// Low single-precision floating-point 4x3 matrix.
 	/// @see gtc_type_precision
-	typedef tmat4x3<f32, lowp> lowp_f32mat4x3;
+	typedef mat<4, 3, f32, lowp> lowp_f32mat4x3;
 
 	/// Low single-precision floating-point 4x4 matrix.
 	/// @see gtc_type_precision
-	typedef tmat4x4<f32, lowp> lowp_f32mat4x4;
+	typedef mat<4, 4, f32, lowp> lowp_f32mat4x4;
 
 	/// Low single-precision floating-point 1x1 matrix.
 	/// @see gtc_type_precision
@@ -1944,39 +1944,39 @@ namespace glm
 
 	/// Low single-precision floating-point 2x2 matrix.
 	/// @see gtc_type_precision
-	typedef tmat2x2<f32, mediump> mediump_f32mat2x2;
+	typedef mat<2, 2, f32, mediump> mediump_f32mat2x2;
 
 	/// Medium single-precision floating-point 2x3 matrix.
 	/// @see gtc_type_precision
-	typedef tmat2x3<f32, mediump> mediump_f32mat2x3;
+	typedef mat<2, 3, f32, mediump> mediump_f32mat2x3;
 
 	/// Medium single-precision floating-point 2x4 matrix.
 	/// @see gtc_type_precision
-	typedef tmat2x4<f32, mediump> mediump_f32mat2x4;
+	typedef mat<2, 4, f32, mediump> mediump_f32mat2x4;
 
 	/// Medium single-precision floating-point 3x2 matrix.
 	/// @see gtc_type_precision
-	typedef tmat3x2<f32, mediump> mediump_f32mat3x2;
+	typedef mat<3, 2, f32, mediump> mediump_f32mat3x2;
 
 	/// Medium single-precision floating-point 3x3 matrix.
 	/// @see gtc_type_precision
-	typedef tmat3x3<f32, mediump> mediump_f32mat3x3;
+	typedef mat<3, 3, f32, mediump> mediump_f32mat3x3;
 
 	/// Medium single-precision floating-point 3x4 matrix.
 	/// @see gtc_type_precision
-	typedef tmat3x4<f32, mediump> mediump_f32mat3x4;
+	typedef mat<3, 4, f32, mediump> mediump_f32mat3x4;
 
 	/// Medium single-precision floating-point 4x2 matrix.
 	/// @see gtc_type_precision
-	typedef tmat4x2<f32, mediump> mediump_f32mat4x2;
+	typedef mat<4, 2, f32, mediump> mediump_f32mat4x2;
 
 	/// Medium single-precision floating-point 4x3 matrix.
 	/// @see gtc_type_precision
-	typedef tmat4x3<f32, mediump> mediump_f32mat4x3;
+	typedef mat<4, 3, f32, mediump> mediump_f32mat4x3;
 
 	/// Medium single-precision floating-point 4x4 matrix.
 	/// @see gtc_type_precision
-	typedef tmat4x4<f32, mediump> mediump_f32mat4x4;
+	typedef mat<4, 4, f32, mediump> mediump_f32mat4x4;
 
 	/// Medium single-precision floating-point 1x1 matrix.
 	/// @see gtc_type_precision
@@ -2001,39 +2001,39 @@ namespace glm
 
 	/// High single-precision floating-point 2x2 matrix.
 	/// @see gtc_type_precision
-	typedef tmat2x2<f32, highp> highp_f32mat2x2;
+	typedef mat<2, 2, f32, highp> highp_f32mat2x2;
 
 	/// High single-precision floating-point 2x3 matrix.
 	/// @see gtc_type_precision
-	typedef tmat2x3<f32, highp> highp_f32mat2x3;
+	typedef mat<2, 3, f32, highp> highp_f32mat2x3;
 
 	/// High single-precision floating-point 2x4 matrix.
 	/// @see gtc_type_precision
-	typedef tmat2x4<f32, highp> highp_f32mat2x4;
+	typedef mat<2, 4, f32, highp> highp_f32mat2x4;
 
 	/// High single-precision floating-point 3x2 matrix.
 	/// @see gtc_type_precision
-	typedef tmat3x2<f32, highp> highp_f32mat3x2;
+	typedef mat<3, 2, f32, highp> highp_f32mat3x2;
 
 	/// High single-precision floating-point 3x3 matrix.
 	/// @see gtc_type_precision
-	typedef tmat3x3<f32, highp> highp_f32mat3x3;
+	typedef mat<3, 3, f32, highp> highp_f32mat3x3;
 
 	/// High single-precision floating-point 3x4 matrix.
 	/// @see gtc_type_precision
-	typedef tmat3x4<f32, highp> highp_f32mat3x4;
+	typedef mat<3, 4, f32, highp> highp_f32mat3x4;
 
 	/// High single-precision floating-point 4x2 matrix.
 	/// @see gtc_type_precision
-	typedef tmat4x2<f32, highp> highp_f32mat4x2;
+	typedef mat<4, 2, f32, highp> highp_f32mat4x2;
 
 	/// High single-precision floating-point 4x3 matrix.
 	/// @see gtc_type_precision
-	typedef tmat4x3<f32, highp> highp_f32mat4x3;
+	typedef mat<4, 3, f32, highp> highp_f32mat4x3;
 
 	/// High single-precision floating-point 4x4 matrix.
 	/// @see gtc_type_precision
-	typedef tmat4x4<f32, highp> highp_f32mat4x4;
+	typedef mat<4, 4, f32, highp> highp_f32mat4x4;
 
 	/// High single-precision floating-point 1x1 matrix.
 	/// @see gtc_type_precision
@@ -2058,39 +2058,39 @@ namespace glm
 
 	/// Low double-precision floating-point 2x2 matrix.
 	/// @see gtc_type_precision
-	typedef tmat2x2<f64, lowp> lowp_f64mat2x2;
+	typedef mat<2, 2, f64, lowp> lowp_f64mat2x2;
 
 	/// Low double-precision floating-point 2x3 matrix.
 	/// @see gtc_type_precision
-	typedef tmat2x3<f64, lowp> lowp_f64mat2x3;
+	typedef mat<2, 3, f64, lowp> lowp_f64mat2x3;
 
 	/// Low double-precision floating-point 2x4 matrix.
 	/// @see gtc_type_precision
-	typedef tmat2x4<f64, lowp> lowp_f64mat2x4;
+	typedef mat<2, 4, f64, lowp> lowp_f64mat2x4;
 
 	/// Low double-precision floating-point 3x2 matrix.
 	/// @see gtc_type_precision
-	typedef tmat3x2<f64, lowp> lowp_f64mat3x2;
+	typedef mat<3, 2, f64, lowp> lowp_f64mat3x2;
 
 	/// Low double-precision floating-point 3x3 matrix.
 	/// @see gtc_type_precision
-	typedef tmat3x3<f64, lowp> lowp_f64mat3x3;
+	typedef mat<3, 3, f64, lowp> lowp_f64mat3x3;
 
 	/// Low double-precision floating-point 3x4 matrix.
 	/// @see gtc_type_precision
-	typedef tmat3x4<f64, lowp> lowp_f64mat3x4;
+	typedef mat<3, 4, f64, lowp> lowp_f64mat3x4;
 
 	/// Low double-precision floating-point 4x2 matrix.
 	/// @see gtc_type_precision
-	typedef tmat4x2<f64, lowp> lowp_f64mat4x2;
+	typedef mat<4, 2, f64, lowp> lowp_f64mat4x2;
 
 	/// Low double-precision floating-point 4x3 matrix.
 	/// @see gtc_type_precision
-	typedef tmat4x3<f64, lowp> lowp_f64mat4x3;
+	typedef mat<4, 3, f64, lowp> lowp_f64mat4x3;
 	
 	/// Low double-precision floating-point 4x4 matrix.
 	/// @see gtc_type_precision
-	typedef tmat4x4<f64, lowp> lowp_f64mat4x4;
+	typedef mat<4, 4, f64, lowp> lowp_f64mat4x4;
 
 	/// Low double-precision floating-point 1x1 matrix.
 	/// @see gtc_type_precision
@@ -2115,39 +2115,39 @@ namespace glm
 
 	/// Medium double-precision floating-point 2x2 matrix.
 	/// @see gtc_type_precision
-	typedef tmat2x2<f64, mediump> mediump_f64mat2x2;
+	typedef mat<2, 2, f64, mediump> mediump_f64mat2x2;
 
 	/// Medium double-precision floating-point 2x3 matrix.
 	/// @see gtc_type_precision
-	typedef tmat2x3<f64, mediump> mediump_f64mat2x3;
+	typedef mat<2, 3, f64, mediump> mediump_f64mat2x3;
 
 	/// Medium double-precision floating-point 2x4 matrix.
 	/// @see gtc_type_precision
-	typedef tmat2x4<f64, mediump> mediump_f64mat2x4;
+	typedef mat<2, 4, f64, mediump> mediump_f64mat2x4;
 
 	/// Medium double-precision floating-point 3x2 matrix.
 	/// @see gtc_type_precision
-	typedef tmat3x2<f64, mediump> mediump_f64mat3x2;
+	typedef mat<3, 2, f64, mediump> mediump_f64mat3x2;
 
 	/// Medium double-precision floating-point 3x3 matrix.
 	/// @see gtc_type_precision
-	typedef tmat3x3<f64, mediump> mediump_f64mat3x3;
+	typedef mat<3, 3, f64, mediump> mediump_f64mat3x3;
 
 	/// Medium double-precision floating-point 3x4 matrix.
 	/// @see gtc_type_precision
-	typedef tmat3x4<f64, mediump> mediump_f64mat3x4;
+	typedef mat<3, 4, f64, mediump> mediump_f64mat3x4;
 
 	/// Medium double-precision floating-point 4x2 matrix.
 	/// @see gtc_type_precision
-	typedef tmat4x2<f64, mediump> mediump_f64mat4x2;
+	typedef mat<4, 2, f64, mediump> mediump_f64mat4x2;
 
 	/// Medium double-precision floating-point 4x3 matrix.
 	/// @see gtc_type_precision
-	typedef tmat4x3<f64, mediump> mediump_f64mat4x3;
+	typedef mat<4, 3, f64, mediump> mediump_f64mat4x3;
 
 	/// Medium double-precision floating-point 4x4 matrix.
 	/// @see gtc_type_precision
-	typedef tmat4x4<f64, mediump> mediump_f64mat4x4;
+	typedef mat<4, 4, f64, mediump> mediump_f64mat4x4;
 
 	/// Medium double-precision floating-point 1x1 matrix.
 	/// @see gtc_type_precision
@@ -2171,39 +2171,39 @@ namespace glm
 
 	/// High double-precision floating-point 2x2 matrix.
 	/// @see gtc_type_precision
-	typedef tmat2x2<f64, highp> highp_f64mat2x2;
+	typedef mat<2, 2, f64, highp> highp_f64mat2x2;
 
 	/// High double-precision floating-point 2x3 matrix.
 	/// @see gtc_type_precision
-	typedef tmat2x3<f64, highp> highp_f64mat2x3;
+	typedef mat<2, 3, f64, highp> highp_f64mat2x3;
 
 	/// High double-precision floating-point 2x4 matrix.
 	/// @see gtc_type_precision
-	typedef tmat2x4<f64, highp> highp_f64mat2x4;
+	typedef mat<2, 4, f64, highp> highp_f64mat2x4;
 
 	/// High double-precision floating-point 3x2 matrix.
 	/// @see gtc_type_precision
-	typedef tmat3x2<f64, highp> highp_f64mat3x2;
+	typedef mat<3, 2, f64, highp> highp_f64mat3x2;
 
 	/// High double-precision floating-point 3x3 matrix.
 	/// @see gtc_type_precision
-	typedef tmat3x3<f64, highp> highp_f64mat3x3;
+	typedef mat<3, 3, f64, highp> highp_f64mat3x3;
 
 	/// High double-precision floating-point 3x4 matrix.
 	/// @see gtc_type_precision
-	typedef tmat3x4<f64, highp> highp_f64mat3x4;
+	typedef mat<3, 4, f64, highp> highp_f64mat3x4;
 
 	/// High double-precision floating-point 4x2 matrix.
 	/// @see gtc_type_precision
-	typedef tmat4x2<f64, highp> highp_f64mat4x2;
+	typedef mat<4, 2, f64, highp> highp_f64mat4x2;
 
 	/// High double-precision floating-point 4x3 matrix.
 	/// @see gtc_type_precision
-	typedef tmat4x3<f64, highp> highp_f64mat4x3;
+	typedef mat<4, 3, f64, highp> highp_f64mat4x3;
 
 	/// High double-precision floating-point 4x4 matrix.
 	/// @see gtc_type_precision
-	typedef tmat4x4<f64, highp> highp_f64mat4x4;
+	typedef mat<4, 4, f64, highp> highp_f64mat4x4;
 
 	/// High double-precision floating-point 1x1 matrix.
 	/// @see gtc_type_precision
diff --git a/glm/gtc/bitfield.hpp b/glm/gtc/bitfield.hpp
index 38a38b69..8a34139b 100644
--- a/glm/gtc/bitfield.hpp
+++ b/glm/gtc/bitfield.hpp
@@ -32,62 +32,62 @@ namespace glm
 	/// Build a mask of 'count' bits
 	///
 	/// @see gtc_bitfield
-	template <typename genIUType>
+	template<typename genIUType>
 	GLM_FUNC_DECL genIUType mask(genIUType Bits);
 	
 	/// Build a mask of 'count' bits
 	///
 	/// @see gtc_bitfield
-	template <typename T, precision P, template <typename, precision> class vecIUType>
+	template<typename T, precision P, template<typename, precision> class vecIUType>
 	GLM_FUNC_DECL vecIUType<T, P> mask(vecIUType<T, P> const & v);
 
 	/// Rotate all bits to the right. All the bits dropped in the right side are inserted back on the left side.
 	///
 	/// @see gtc_bitfield
-	template <typename genIUType>
+	template<typename genIUType>
 	GLM_FUNC_DECL genIUType bitfieldRotateRight(genIUType In, int Shift);
 
 	/// Rotate all bits to the right. All the bits dropped in the right side are inserted back on the left side.
 	///
 	/// @see gtc_bitfield
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> bitfieldRotateRight(vecType<T, P> const & In, int Shift);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, T, P> bitfieldRotateRight(vecType<L, T, P> const & In, int Shift);
 
 	/// Rotate all bits to the left. All the bits dropped in the left side are inserted back on the right side.
 	///
 	/// @see gtc_bitfield
-	template <typename genIUType>
+	template<typename genIUType>
 	GLM_FUNC_DECL genIUType bitfieldRotateLeft(genIUType In, int Shift);
 
 	/// Rotate all bits to the left. All the bits dropped in the left side are inserted back on the right side.
 	///
 	/// @see gtc_bitfield
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> bitfieldRotateLeft(vecType<T, P> const & In, int Shift);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, T, P> bitfieldRotateLeft(vecType<L, T, P> const & In, int Shift);
 
 	/// Set to 1 a range of bits.
 	///
 	/// @see gtc_bitfield
-	template <typename genIUType>
+	template<typename genIUType>
 	GLM_FUNC_DECL genIUType bitfieldFillOne(genIUType Value, int FirstBit, int BitCount);
 
 	/// Set to 1 a range of bits.
 	///
 	/// @see gtc_bitfield
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> bitfieldFillOne(vecType<T, P> const & Value, int FirstBit, int BitCount);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, T, P> bitfieldFillOne(vecType<L, T, P> const & Value, int FirstBit, int BitCount);
 
 	/// Set to 0 a range of bits.
 	///
 	/// @see gtc_bitfield
-	template <typename genIUType>
+	template<typename genIUType>
 	GLM_FUNC_DECL genIUType bitfieldFillZero(genIUType Value, int FirstBit, int BitCount);
 
 	/// Set to 0 a range of bits.
 	///
 	/// @see gtc_bitfield
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> bitfieldFillZero(vecType<T, P> const & Value, int FirstBit, int BitCount);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, T, P> bitfieldFillZero(vecType<L, T, P> const & Value, int FirstBit, int BitCount);
 
 	/// Interleaves the bits of x and y.
 	/// The first bit is the first bit of x followed by the first bit of y.
diff --git a/glm/gtc/bitfield.inl b/glm/gtc/bitfield.inl
index 490cfb32..4331eec5 100644
--- a/glm/gtc/bitfield.inl
+++ b/glm/gtc/bitfield.inl
@@ -6,16 +6,16 @@
 namespace glm{
 namespace detail
 {
-	template <typename PARAM, typename RET>
+	template<typename PARAM, typename RET>
 	GLM_FUNC_DECL RET bitfieldInterleave(PARAM x, PARAM y);
 
-	template <typename PARAM, typename RET>
+	template<typename PARAM, typename RET>
 	GLM_FUNC_DECL RET bitfieldInterleave(PARAM x, PARAM y, PARAM z);
 
-	template <typename PARAM, typename RET>
+	template<typename PARAM, typename RET>
 	GLM_FUNC_DECL RET bitfieldInterleave(PARAM x, PARAM y, PARAM z, PARAM w);
 
-	template <>
+	template<>
 	GLM_FUNC_QUALIFIER glm::uint16 bitfieldInterleave(glm::uint8 x, glm::uint8 y)
 	{
 		glm::uint16 REG1(x);
@@ -33,7 +33,7 @@ namespace detail
 		return REG1 | (REG2 << 1);
 	}
 
-	template <>
+	template<>
 	GLM_FUNC_QUALIFIER glm::uint32 bitfieldInterleave(glm::uint16 x, glm::uint16 y)
 	{
 		glm::uint32 REG1(x);
@@ -54,7 +54,7 @@ namespace detail
 		return REG1 | (REG2 << 1);
 	}
 
-	template <>
+	template<>
 	GLM_FUNC_QUALIFIER glm::uint64 bitfieldInterleave(glm::uint32 x, glm::uint32 y)
 	{
 		glm::uint64 REG1(x);
@@ -78,7 +78,7 @@ namespace detail
 		return REG1 | (REG2 << 1);
 	}
 
-	template <>
+	template<>
 	GLM_FUNC_QUALIFIER glm::uint32 bitfieldInterleave(glm::uint8 x, glm::uint8 y, glm::uint8 z)
 	{
 		glm::uint32 REG1(x);
@@ -104,7 +104,7 @@ namespace detail
 		return REG1 | (REG2 << 1) | (REG3 << 2);
 	}
 		
-	template <>
+	template<>
 	GLM_FUNC_QUALIFIER glm::uint64 bitfieldInterleave(glm::uint16 x, glm::uint16 y, glm::uint16 z)
 	{
 		glm::uint64 REG1(x);
@@ -134,7 +134,7 @@ namespace detail
 		return REG1 | (REG2 << 1) | (REG3 << 2);
 	}
 
-	template <>
+	template<>
 	GLM_FUNC_QUALIFIER glm::uint64 bitfieldInterleave(glm::uint32 x, glm::uint32 y, glm::uint32 z)
 	{
 		glm::uint64 REG1(x);
@@ -164,7 +164,7 @@ namespace detail
 		return REG1 | (REG2 << 1) | (REG3 << 2);
 	}
 
-	template <>
+	template<>
 	GLM_FUNC_QUALIFIER glm::uint32 bitfieldInterleave(glm::uint8 x, glm::uint8 y, glm::uint8 z, glm::uint8 w)
 	{
 		glm::uint32 REG1(x);
@@ -190,7 +190,7 @@ namespace detail
 		return REG1 | (REG2 << 1) | (REG3 << 2) | (REG4 << 3);
 	}
 
-	template <>
+	template<>
 	GLM_FUNC_QUALIFIER glm::uint64 bitfieldInterleave(glm::uint16 x, glm::uint16 y, glm::uint16 z, glm::uint16 w)
 	{
 		glm::uint64 REG1(x);
@@ -222,7 +222,7 @@ namespace detail
 	}
 }//namespace detail
 
-	template <typename genIUType>
+	template<typename genIUType>
 	GLM_FUNC_QUALIFIER genIUType mask(genIUType Bits)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'mask' accepts only integer values");
@@ -230,15 +230,15 @@ namespace detail
 		return Bits >= sizeof(genIUType) * 8 ? ~static_cast<genIUType>(0) : (static_cast<genIUType>(1) << Bits) - static_cast<genIUType>(1);
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecIUType>
-	GLM_FUNC_QUALIFIER vecIUType<T, P> mask(vecIUType<T, P> const& v)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecIUType>
+	GLM_FUNC_QUALIFIER vecIUType<L, T, P> mask(vecIUType<L, T, P> const& v)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_integer, "'mask' accepts only integer values");
 
-		return detail::functor1<T, T, P, vecIUType>::call(mask, v);
+		return detail::functor1<L, T, T, P>::call(mask, v);
 	}
 
-	template <typename genIType>
+	template<typename genIType>
 	GLM_FUNC_QUALIFIER genIType bitfieldRotateRight(genIType In, int Shift)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<genIType>::is_integer, "'bitfieldRotateRight' accepts only integer values");
@@ -247,8 +247,8 @@ namespace detail
 		return (In << static_cast<genIType>(Shift)) | (In >> static_cast<genIType>(BitSize - Shift));
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> bitfieldRotateRight(vecType<T, P> const & In, int Shift)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> bitfieldRotateRight(vecType<L, T, P> const & In, int Shift)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_integer, "'bitfieldRotateRight' accepts only integer values");
 
@@ -256,7 +256,7 @@ namespace detail
 		return (In << static_cast<T>(Shift)) | (In >> static_cast<T>(BitSize - Shift));
 	}
 
-	template <typename genIType>
+	template<typename genIType>
 	GLM_FUNC_QUALIFIER genIType bitfieldRotateLeft(genIType In, int Shift)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<genIType>::is_integer, "'bitfieldRotateLeft' accepts only integer values");
@@ -265,8 +265,8 @@ namespace detail
 		return (In >> static_cast<genIType>(Shift)) | (In << static_cast<genIType>(BitSize - Shift));
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> bitfieldRotateLeft(vecType<T, P> const& In, int Shift)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> bitfieldRotateLeft(vecType<L, T, P> const& In, int Shift)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_integer, "'bitfieldRotateLeft' accepts only integer values");
 
@@ -274,26 +274,26 @@ namespace detail
 		return (In >> static_cast<T>(Shift)) | (In << static_cast<T>(BitSize - Shift));
 	}
 
-	template <typename genIUType>
+	template<typename genIUType>
 	GLM_FUNC_QUALIFIER genIUType bitfieldFillOne(genIUType Value, int FirstBit, int BitCount)
 	{
 		return Value | static_cast<genIUType>(mask(BitCount) << FirstBit);
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> bitfieldFillOne(vecType<T, P> const& Value, int FirstBit, int BitCount)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> bitfieldFillOne(vecType<L, T, P> const& Value, int FirstBit, int BitCount)
 	{
 		return Value | static_cast<T>(mask(BitCount) << FirstBit);
 	}
 
-	template <typename genIUType>
+	template<typename genIUType>
 	GLM_FUNC_QUALIFIER genIUType bitfieldFillZero(genIUType Value, int FirstBit, int BitCount)
 	{
 		return Value & static_cast<genIUType>(~(mask(BitCount) << FirstBit));
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> bitfieldFillZero(vecType<T, P> const& Value, int FirstBit, int BitCount)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> bitfieldFillZero(vecType<L, T, P> const& Value, int FirstBit, int BitCount)
 	{
 		return Value & static_cast<T>(~(mask(BitCount) << FirstBit));
 	}
diff --git a/glm/gtc/color_space.hpp b/glm/gtc/color_space.hpp
index 9ae9692f..da300d93 100644
--- a/glm/gtc/color_space.hpp
+++ b/glm/gtc/color_space.hpp
@@ -32,23 +32,23 @@ namespace glm
 
 	/// Convert a linear color to sRGB color using a standard gamma correction.
 	/// IEC 61966-2-1:1999 / Rec. 709 specification https://www.w3.org/Graphics/Color/srgb
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> convertLinearToSRGB(vecType<T, P> const & ColorLinear);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, T, P> convertLinearToSRGB(vecType<L, T, P> const & ColorLinear);
 
 	/// Convert a linear color to sRGB color using a custom gamma correction.
 	/// IEC 61966-2-1:1999 / Rec. 709 specification https://www.w3.org/Graphics/Color/srgb
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> convertLinearToSRGB(vecType<T, P> const & ColorLinear, T Gamma);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, T, P> convertLinearToSRGB(vecType<L, T, P> const & ColorLinear, T Gamma);
 
 	/// Convert a sRGB color to linear color using a standard gamma correction.
 	/// IEC 61966-2-1:1999 / Rec. 709 specification https://www.w3.org/Graphics/Color/srgb
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> convertSRGBToLinear(vecType<T, P> const & ColorSRGB);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, T, P> convertSRGBToLinear(vecType<L, T, P> const & ColorSRGB);
 
 	/// Convert a sRGB color to linear color using a custom gamma correction.
 	// IEC 61966-2-1:1999 / Rec. 709 specification https://www.w3.org/Graphics/Color/srgb
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> convertSRGBToLinear(vecType<T, P> const & ColorSRGB, T Gamma);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, T, P> convertSRGBToLinear(vecType<L, T, P> const & ColorSRGB, T Gamma);
 
 	/// @}
 } //namespace glm
diff --git a/glm/gtc/color_space.inl b/glm/gtc/color_space.inl
index fb6f4230..b9475bd2 100644
--- a/glm/gtc/color_space.inl
+++ b/glm/gtc/color_space.inl
@@ -4,82 +4,82 @@
 namespace glm{
 namespace detail
 {
-	template <typename T, precision P, template <typename, precision> class vecType>
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
 	struct compute_rgbToSrgb
 	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const& ColorRGB, T GammaCorrection)
+		GLM_FUNC_QUALIFIER static vecType<L, T, P> call(vecType<L, T, P> const& ColorRGB, T GammaCorrection)
 		{
-			vecType<T, P> const ClampedColor(clamp(ColorRGB, static_cast<T>(0), static_cast<T>(1)));
+			vecType<L, T, P> const ClampedColor(clamp(ColorRGB, static_cast<T>(0), static_cast<T>(1)));
 
 			return mix(
-				pow(ClampedColor, vecType<T, P>(GammaCorrection)) * static_cast<T>(1.055) - static_cast<T>(0.055),
+				pow(ClampedColor, vecType<L, T, P>(GammaCorrection)) * static_cast<T>(1.055) - static_cast<T>(0.055),
 				ClampedColor * static_cast<T>(12.92),
-				lessThan(ClampedColor, vecType<T, P>(static_cast<T>(0.0031308))));
+				lessThan(ClampedColor, vecType<L, T, P>(static_cast<T>(0.0031308))));
 		}
 	};
 
-	template <typename T, precision P>
-	struct compute_rgbToSrgb<T, P, tvec4>
+	template<typename T, precision P>
+	struct compute_rgbToSrgb<4, T, P, vec>
 	{
-		GLM_FUNC_QUALIFIER static tvec4<T, P> call(tvec4<T, P> const& ColorRGB, T GammaCorrection)
+		GLM_FUNC_QUALIFIER static vec<4, T, P> call(vec<4, T, P> const& ColorRGB, T GammaCorrection)
 		{
-			return tvec4<T, P>(compute_rgbToSrgb<T, P, tvec3>::call(tvec3<T, P>(ColorRGB), GammaCorrection), ColorRGB.a);
+			return vec<4, T, P>(compute_rgbToSrgb<3, T, P, vec>::call(vec<3, T, P>(ColorRGB), GammaCorrection), ColorRGB.a);
 		}
 	};
 
-	template <typename T, precision P, template <typename, precision> class vecType>
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
 	struct compute_srgbToRgb
 	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const& ColorSRGB, T Gamma)
+		GLM_FUNC_QUALIFIER static vecType<L, T, P> call(vecType<L, T, P> const& ColorSRGB, T Gamma)
 		{
 			return mix(
-				pow((ColorSRGB + static_cast<T>(0.055)) * static_cast<T>(0.94786729857819905213270142180095), vecType<T, P>(Gamma)),
+				pow((ColorSRGB + static_cast<T>(0.055)) * static_cast<T>(0.94786729857819905213270142180095), vecType<L, T, P>(Gamma)),
 				ColorSRGB * static_cast<T>(0.07739938080495356037151702786378),
-				lessThanEqual(ColorSRGB, vecType<T, P>(static_cast<T>(0.04045))));
+				lessThanEqual(ColorSRGB, vecType<L, T, P>(static_cast<T>(0.04045))));
 		}
 	};
 
-	template <typename T, precision P>
-	struct compute_srgbToRgb<T, P, tvec4>
+	template<typename T, precision P>
+	struct compute_srgbToRgb<4, T, P, vec>
 	{
-		GLM_FUNC_QUALIFIER static tvec4<T, P> call(tvec4<T, P> const& ColorSRGB, T Gamma)
+		GLM_FUNC_QUALIFIER static vec<4, T, P> call(vec<4, T, P> const& ColorSRGB, T Gamma)
 		{
-			return tvec4<T, P>(compute_srgbToRgb<T, P, tvec3>::call(tvec3<T, P>(ColorSRGB), Gamma), ColorSRGB.a);
+			return vec<4, T, P>(compute_srgbToRgb<3, T, P, vec>::call(vec<3, T, P>(ColorSRGB), Gamma), ColorSRGB.a);
 		}
 	};
 }//namespace detail
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> convertLinearToSRGB(vecType<T, P> const& ColorLinear)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> convertLinearToSRGB(vecType<L, T, P> const& ColorLinear)
 	{
-		return detail::compute_rgbToSrgb<T, P, vecType>::call(ColorLinear, static_cast<T>(0.41666));
+		return detail::compute_rgbToSrgb<L, T, P, vecType>::call(ColorLinear, static_cast<T>(0.41666));
 	}
 
 	// Based on Ian Taylor http://chilliant.blogspot.fr/2012/08/srgb-approximations-for-hlsl.html
-	template <>
-	GLM_FUNC_QUALIFIER tvec3<float, lowp> convertLinearToSRGB(tvec3<float, lowp> const& ColorLinear)
+	template<>
+	GLM_FUNC_QUALIFIER vec<3, float, lowp> convertLinearToSRGB(vec<3, float, lowp> const& ColorLinear)
 	{
-		tvec3<float, lowp> S1 = sqrt(ColorLinear);
-		tvec3<float, lowp> S2 = sqrt(S1);
-		tvec3<float, lowp> S3 = sqrt(S2);
+		vec<3, float, lowp> S1 = sqrt(ColorLinear);
+		vec<3, float, lowp> S2 = sqrt(S1);
+		vec<3, float, lowp> S3 = sqrt(S2);
 		return 0.662002687f * S1 + 0.684122060f * S2 - 0.323583601f * S3 - 0.0225411470f * ColorLinear;
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> convertLinearToSRGB(vecType<T, P> const& ColorLinear, T Gamma)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> convertLinearToSRGB(vecType<L, T, P> const& ColorLinear, T Gamma)
 	{
-		return detail::compute_rgbToSrgb<T, P, vecType>::call(ColorLinear, static_cast<T>(1) / Gamma);
+		return detail::compute_rgbToSrgb<L, T, P, vecType>::call(ColorLinear, static_cast<T>(1) / Gamma);
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> convertSRGBToLinear(vecType<T, P> const& ColorSRGB)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> convertSRGBToLinear(vecType<L, T, P> const& ColorSRGB)
 	{
-		return detail::compute_srgbToRgb<T, P, vecType>::call(ColorSRGB, static_cast<T>(2.4));
+		return detail::compute_srgbToRgb<L, T, P, vecType>::call(ColorSRGB, static_cast<T>(2.4));
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> convertSRGBToLinear(vecType<T, P> const& ColorSRGB, T Gamma)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> convertSRGBToLinear(vecType<L, T, P> const& ColorSRGB, T Gamma)
 	{
-		return detail::compute_srgbToRgb<T, P, vecType>::call(ColorSRGB, Gamma);
+		return detail::compute_srgbToRgb<L, T, P, vecType>::call(ColorSRGB, Gamma);
 	}
 }//namespace glm
diff --git a/glm/gtc/constants.hpp b/glm/gtc/constants.hpp
index 059b6c5b..dd8f2856 100644
--- a/glm/gtc/constants.hpp
+++ b/glm/gtc/constants.hpp
@@ -26,147 +26,147 @@ namespace glm
 
 	/// Return the epsilon constant for floating point types.
 	/// @see gtc_constants
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL GLM_CONSTEXPR genType epsilon();
 
 	/// Return 0.
 	/// @see gtc_constants
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL GLM_CONSTEXPR genType zero();
 
 	/// Return 1.
 	/// @see gtc_constants
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL GLM_CONSTEXPR genType one();
 
 	/// Return the pi constant.
 	/// @see gtc_constants
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL GLM_CONSTEXPR genType pi();
 
 	/// Return pi * 2.
 	/// @see gtc_constants
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL GLM_CONSTEXPR genType two_pi();
 
 	/// Return square root of pi.
 	/// @see gtc_constants
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL GLM_CONSTEXPR genType root_pi();
 
 	/// Return pi / 2.
 	/// @see gtc_constants
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL GLM_CONSTEXPR genType half_pi();
 
 	/// Return pi / 2 * 3.
 	/// @see gtc_constants
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL GLM_CONSTEXPR genType three_over_two_pi();
 
 	/// Return pi / 4.
 	/// @see gtc_constants
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL GLM_CONSTEXPR genType quarter_pi();
 
 	/// Return 1 / pi.
 	/// @see gtc_constants
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL GLM_CONSTEXPR genType one_over_pi();
 
 	/// Return 1 / (pi * 2).
 	/// @see gtc_constants
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL GLM_CONSTEXPR genType one_over_two_pi();
 
 	/// Return 2 / pi.
 	/// @see gtc_constants
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL GLM_CONSTEXPR genType two_over_pi();
 
 	/// Return 4 / pi.
 	/// @see gtc_constants
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL GLM_CONSTEXPR genType four_over_pi();
 
 	/// Return 2 / sqrt(pi).
 	/// @see gtc_constants
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL GLM_CONSTEXPR genType two_over_root_pi();
 
 	/// Return 1 / sqrt(2).
 	/// @see gtc_constants
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL GLM_CONSTEXPR genType one_over_root_two();
 
 	/// Return sqrt(pi / 2).
 	/// @see gtc_constants
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL GLM_CONSTEXPR genType root_half_pi();
 
 	/// Return sqrt(2 * pi).
 	/// @see gtc_constants
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL GLM_CONSTEXPR genType root_two_pi();
 
 	/// Return sqrt(ln(4)).
 	/// @see gtc_constants
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL GLM_CONSTEXPR genType root_ln_four();
 
 	/// Return e constant.
 	/// @see gtc_constants
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL GLM_CONSTEXPR genType e();
 
 	/// Return Euler's constant.
 	/// @see gtc_constants
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL GLM_CONSTEXPR genType euler();
 
 	/// Return sqrt(2).
 	/// @see gtc_constants
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL GLM_CONSTEXPR genType root_two();
 
 	/// Return sqrt(3).
 	/// @see gtc_constants
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL GLM_CONSTEXPR genType root_three();
 
 	/// Return sqrt(5).
 	/// @see gtc_constants
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL GLM_CONSTEXPR genType root_five();
 
 	/// Return ln(2).
 	/// @see gtc_constants
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL GLM_CONSTEXPR genType ln_two();
 
 	/// Return ln(10).
 	/// @see gtc_constants
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL GLM_CONSTEXPR genType ln_ten();
 
 	/// Return ln(ln(2)).
 	/// @see gtc_constants
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL GLM_CONSTEXPR genType ln_ln_two();
 
 	/// Return 1 / 3.
 	/// @see gtc_constants
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL GLM_CONSTEXPR genType third();
 
 	/// Return 2 / 3.
 	/// @see gtc_constants
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL GLM_CONSTEXPR genType two_thirds();
 
 	/// Return the golden ratio constant.
 	/// @see gtc_constants
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL GLM_CONSTEXPR genType golden_ratio();
 
 	/// @}
diff --git a/glm/gtc/constants.inl b/glm/gtc/constants.inl
index cb451d0d..2ea10855 100644
--- a/glm/gtc/constants.inl
+++ b/glm/gtc/constants.inl
@@ -5,175 +5,175 @@
 
 namespace glm
 {
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType epsilon()
 	{
 		return std::numeric_limits<genType>::epsilon();
 	}
 
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType zero()
 	{
 		return genType(0);
 	}
 
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType one()
 	{
 		return genType(1);
 	}
 
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType pi()
 	{
 		return genType(3.14159265358979323846264338327950288);
 	}
 
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType two_pi()
 	{
 		return genType(6.28318530717958647692528676655900576);
 	}
 
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType root_pi()
 	{
 		return genType(1.772453850905516027);
 	}
 
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType half_pi()
 	{
 		return genType(1.57079632679489661923132169163975144);
 	}
 
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType three_over_two_pi()
 	{
 		return genType(4.71238898038468985769396507491925432);           
 	}
 
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType quarter_pi()
 	{
 		return genType(0.785398163397448309615660845819875721);
 	}
 
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType one_over_pi()
 	{
 		return genType(0.318309886183790671537767526745028724);
 	}
 
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType one_over_two_pi()
 	{
 		return genType(0.159154943091895335768883763372514362);
 	}
 
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType two_over_pi()
 	{
 		return genType(0.636619772367581343075535053490057448);
 	}
 
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType four_over_pi()
 	{
 		return genType(1.273239544735162686151070106980114898);
 	}
 
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType two_over_root_pi()
 	{
 		return genType(1.12837916709551257389615890312154517);
 	}
 
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType one_over_root_two()
 	{
 		return genType(0.707106781186547524400844362104849039);
 	}
 
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType root_half_pi()
 	{
 		return genType(1.253314137315500251);
 	}
 
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType root_two_pi()
 	{
 		return genType(2.506628274631000502);
 	}
 
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType root_ln_four()
 	{
 		return genType(1.17741002251547469);
 	}
 
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType e()
 	{
 		return genType(2.71828182845904523536);
 	}
 
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType euler()
 	{
 		return genType(0.577215664901532860606);
 	}
 
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType root_two()
 	{
 		return genType(1.41421356237309504880168872420969808);
 	}
 
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType root_three()
 	{
 		return genType(1.73205080756887729352744634150587236);
 	}
 
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType root_five()
 	{
 		return genType(2.23606797749978969640917366873127623);
 	}
 
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType ln_two()
 	{
 		return genType(0.693147180559945309417232121458176568);
 	}
 
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType ln_ten()
 	{
 		return genType(2.30258509299404568401799145468436421);
 	}
 
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType ln_ln_two()
 	{
 		return genType(-0.3665129205816643);
 	}
 
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType third()
 	{
 		return genType(0.3333333333333333333333333333333333333333);
 	}
 
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType two_thirds()
 	{
 		return genType(0.666666666666666666666666666666666666667);
 	}
 
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType golden_ratio()
 	{
 		return genType(1.61803398874989484820458683436563811);
diff --git a/glm/gtc/epsilon.hpp b/glm/gtc/epsilon.hpp
index d3668e91..5510daf2 100644
--- a/glm/gtc/epsilon.hpp
+++ b/glm/gtc/epsilon.hpp
@@ -30,17 +30,17 @@ namespace glm
 	/// True if this expression is satisfied.
 	///
 	/// @see gtc_epsilon
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<bool, P> epsilonEqual(
-		vecType<T, P> const & x,
-		vecType<T, P> const & y,
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, bool, P> epsilonEqual(
+		vecType<L, T, P> const& x,
+		vecType<L, T, P> const& y,
 		T const & epsilon);
 
 	/// Returns the component-wise comparison of |x - y| < epsilon.
 	/// True if this expression is satisfied.
 	///
 	/// @see gtc_epsilon
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL bool epsilonEqual(
 		genType const & x,
 		genType const & y,
@@ -50,7 +50,7 @@ namespace glm
 	/// True if this expression is not satisfied.
 	///
 	/// @see gtc_epsilon
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL typename genType::boolType epsilonNotEqual(
 		genType const & x,
 		genType const & y,
@@ -60,7 +60,7 @@ namespace glm
 	/// True if this expression is not satisfied.
 	///
 	/// @see gtc_epsilon
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL bool epsilonNotEqual(
 		genType const & x,
 		genType const & y,
diff --git a/glm/gtc/epsilon.inl b/glm/gtc/epsilon.inl
index b5577d93..fd86b7ad 100644
--- a/glm/gtc/epsilon.inl
+++ b/glm/gtc/epsilon.inl
@@ -11,7 +11,7 @@
 
 namespace glm
 {
-	template <>
+	template<>
 	GLM_FUNC_QUALIFIER bool epsilonEqual
 	(
 		float const & x,
@@ -22,7 +22,7 @@ namespace glm
 		return abs(x - y) < epsilon;
 	}
 
-	template <>
+	template<>
 	GLM_FUNC_QUALIFIER bool epsilonEqual
 	(
 		double const & x,
@@ -33,7 +33,7 @@ namespace glm
 		return abs(x - y) < epsilon;
 	}
 
-	template <>
+	template<>
 	GLM_FUNC_QUALIFIER bool epsilonNotEqual
 	(
 		float const & x,
@@ -44,7 +44,7 @@ namespace glm
 		return abs(x - y) >= epsilon;
 	}
 
-	template <>
+	template<>
 	GLM_FUNC_QUALIFIER bool epsilonNotEqual
 	(
 		double const & x,
@@ -55,71 +55,71 @@ namespace glm
 		return abs(x - y) >= epsilon;
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<bool, P> epsilonEqual
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, bool, P> epsilonEqual
 	(
-		vecType<T, P> const & x,
-		vecType<T, P> const & y,
+		vecType<L, T, P> const& x,
+		vecType<L, T, P> const& y,
 		T const & epsilon
 	)
 	{
-		return lessThan(abs(x - y), vecType<T, P>(epsilon));
+		return lessThan(abs(x - y), vecType<L, T, P>(epsilon));
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<bool, P> epsilonEqual
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, bool, P> epsilonEqual
 	(
-		vecType<T, P> const & x,
-		vecType<T, P> const & y,
-		vecType<T, P> const & epsilon
+		vecType<L, T, P> const& x,
+		vecType<L, T, P> const& y,
+		vecType<L, T, P> const& epsilon
 	)
 	{
-		return lessThan(abs(x - y), vecType<T, P>(epsilon));
+		return lessThan(abs(x - y), vecType<L, T, P>(epsilon));
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<bool, P> epsilonNotEqual
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, bool, P> epsilonNotEqual
 	(
-		vecType<T, P> const & x,
-		vecType<T, P> const & y,
+		vecType<L, T, P> const& x,
+		vecType<L, T, P> const& y,
 		T const & epsilon
 	)
 	{
-		return greaterThanEqual(abs(x - y), vecType<T, P>(epsilon));
+		return greaterThanEqual(abs(x - y), vecType<L, T, P>(epsilon));
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<bool, P> epsilonNotEqual
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, bool, P> epsilonNotEqual
 	(
-		vecType<T, P> const & x,
-		vecType<T, P> const & y,
-		vecType<T, P> const & epsilon
+		vecType<L, T, P> const& x,
+		vecType<L, T, P> const& y,
+		vecType<L, T, P> const& epsilon
 	)
 	{
-		return greaterThanEqual(abs(x - y), vecType<T, P>(epsilon));
+		return greaterThanEqual(abs(x - y), vecType<L, T, P>(epsilon));
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<bool, P> epsilonEqual
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, bool, P> epsilonEqual
 	(
 		tquat<T, P> const & x,
 		tquat<T, P> const & y,
 		T const & epsilon
 	)
 	{
-		tvec4<T, P> v(x.x - y.x, x.y - y.y, x.z - y.z, x.w - y.w);
-		return lessThan(abs(v), tvec4<T, P>(epsilon));
+		vec<4, T, P> v(x.x - y.x, x.y - y.y, x.z - y.z, x.w - y.w);
+		return lessThan(abs(v), vec<4, T, P>(epsilon));
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<bool, P> epsilonNotEqual
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, bool, P> epsilonNotEqual
 	(
 		tquat<T, P> const & x,
 		tquat<T, P> const & y,
 		T const & epsilon
 	)
 	{
-		tvec4<T, P> v(x.x - y.x, x.y - y.y, x.z - y.z, x.w - y.w);
-		return greaterThanEqual(abs(v), tvec4<T, P>(epsilon));
+		vec<4, T, P> v(x.x - y.x, x.y - y.y, x.z - y.z, x.w - y.w);
+		return greaterThanEqual(abs(v), vec<4, T, P>(epsilon));
 	}
 }//namespace glm
diff --git a/glm/gtc/functions.hpp b/glm/gtc/functions.hpp
index c8b2ee3c..89048cc1 100644
--- a/glm/gtc/functions.hpp
+++ b/glm/gtc/functions.hpp
@@ -30,7 +30,7 @@ namespace glm
 	/// 1D gauss function
 	///
 	/// @see gtc_epsilon
-	template <typename T>
+	template<typename T>
 	GLM_FUNC_DECL T gauss(
 		T x,
 		T ExpectedValue,
@@ -39,11 +39,11 @@ namespace glm
 	/// 2D gauss function
 	///
 	/// @see gtc_epsilon
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_DECL T gauss(
-		tvec2<T, P> const& Coord,
-		tvec2<T, P> const& ExpectedValue,
-		tvec2<T, P> const& StandardDeviation);
+		vec<2, T, P> const& Coord,
+		vec<2, T, P> const& ExpectedValue,
+		vec<2, T, P> const& StandardDeviation);
 
 	/// @}
 }//namespace glm
diff --git a/glm/gtc/functions.inl b/glm/gtc/functions.inl
index 1dbc4967..b332e9eb 100644
--- a/glm/gtc/functions.inl
+++ b/glm/gtc/functions.inl
@@ -5,7 +5,7 @@
 
 namespace glm
 {
-	template <typename T>
+	template<typename T>
 	GLM_FUNC_QUALIFIER T gauss
 	(
 		T x,
@@ -16,15 +16,15 @@ namespace glm
 		return exp(-((x - ExpectedValue) * (x - ExpectedValue)) / (static_cast<T>(2) * StandardDeviation * StandardDeviation)) / (StandardDeviation * sqrt(static_cast<T>(6.28318530717958647692528676655900576)));
 	}
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER T gauss
 	(
-		tvec2<T, P> const& Coord,
-		tvec2<T, P> const& ExpectedValue,
-		tvec2<T, P> const& StandardDeviation
+		vec<2, T, P> const& Coord,
+		vec<2, T, P> const& ExpectedValue,
+		vec<2, T, P> const& StandardDeviation
 	)
 	{
-		tvec2<T, P> const Squared = ((Coord - ExpectedValue) * (Coord - ExpectedValue)) / (static_cast<T>(2) * StandardDeviation * StandardDeviation);
+		vec<2, T, P> const Squared = ((Coord - ExpectedValue) * (Coord - ExpectedValue)) / (static_cast<T>(2) * StandardDeviation * StandardDeviation);
 		return exp(-(Squared.x + Squared.y));
 	}
 }//namespace glm
diff --git a/glm/gtc/integer.hpp b/glm/gtc/integer.hpp
index 69ffb1d3..894500c5 100644
--- a/glm/gtc/integer.hpp
+++ b/glm/gtc/integer.hpp
@@ -32,7 +32,7 @@ namespace glm
 
 	/// Returns the log2 of x for integer values. Can be reliably using to compute mipmap count from the texture size.
 	/// @see gtc_integer
-	template <typename genIUType>
+	template<typename genIUType>
 	GLM_FUNC_DECL genIUType log2(genIUType x);
 
 	/// Modulus. Returns x % y
@@ -43,7 +43,7 @@ namespace glm
 	/// @see gtc_integer
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/mod.xml">GLSL mod man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
-	template <typename genIUType>
+	template<typename genIUType>
 	GLM_FUNC_DECL genIUType mod(genIUType x, genIUType y);
 
 	/// Modulus. Returns x % y
@@ -55,8 +55,8 @@ namespace glm
 	/// @see gtc_integer
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/mod.xml">GLSL mod man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> mod(vecType<T, P> const & x, T y);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, T, P> mod(vecType<L, T, P> const & x, T y);
 
 	/// Modulus. Returns x % y
 	/// for each component in x using the floating point value y.
@@ -67,8 +67,8 @@ namespace glm
 	/// @see gtc_integer
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/mod.xml">GLSL mod man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> mod(vecType<T, P> const & x, vecType<T, P> const & y);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, T, P> mod(vecType<L, T, P> const & x, vecType<L, T, P> const & y);
 
 	/// Returns a value equal to the nearest integer to x.
 	/// The fraction 0.5 will round in a direction chosen by the
@@ -80,8 +80,8 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/round.xml">GLSL round man page</a>
 	/// @see gtc_integer
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<int, P> iround(vecType<T, P> const & x);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, int, P> iround(vecType<L, T, P> const & x);
 
 	/// Returns a value equal to the nearest integer to x.
 	/// The fraction 0.5 will round in a direction chosen by the
@@ -93,8 +93,8 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/round.xml">GLSL round man page</a>
 	/// @see gtc_integer
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<uint, P> uround(vecType<T, P> const & x);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, uint, P> uround(vecType<L, T, P> const & x);
 
 	/// @}
 } //namespace glm
diff --git a/glm/gtc/integer.inl b/glm/gtc/integer.inl
index 7ce2918a..1dfe9038 100644
--- a/glm/gtc/integer.inl
+++ b/glm/gtc/integer.inl
@@ -4,36 +4,36 @@
 namespace glm{
 namespace detail
 {
-	template <typename T, precision P, template <typename, precision> class vecType, bool Aligned>
-	struct compute_log2<T, P, vecType, false, Aligned>
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType, bool Aligned>
+	struct compute_log2<L, T, P, vecType, false, Aligned>
 	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & vec)
+		GLM_FUNC_QUALIFIER static vecType<L, T, P> call(vecType<L, T, P> const& v)
 		{
 			//Equivalent to return findMSB(vec); but save one function call in ASM with VC
 			//return findMSB(vec);
-			return vecType<T, P>(detail::compute_findMSB_vec<T, P, vecType, sizeof(T) * 8>::call(vec));
+			return vecType<L, T, P>(detail::compute_findMSB_vec<L, T, P, vecType, sizeof(T) * 8>::call(v));
 		}
 	};
 
 #	if GLM_HAS_BITSCAN_WINDOWS
-		template <precision P, bool Aligned>
-		struct compute_log2<int, P, tvec4, false, Aligned>
+		template<precision P, bool Aligned>
+		struct compute_log2<4, int, P, vec, false, Aligned>
 		{
-			GLM_FUNC_QUALIFIER static tvec4<int, P> call(tvec4<int, P> const & vec)
+			GLM_FUNC_QUALIFIER static vec<4, int, P> call(vec<4, int, P> const& v)
 			{
-				tvec4<int, P> Result(glm::uninitialize);
+				vec<4, int, P> Result(glm::uninitialize);
 
-				_BitScanReverse(reinterpret_cast<unsigned long*>(&Result.x), vec.x);
-				_BitScanReverse(reinterpret_cast<unsigned long*>(&Result.y), vec.y);
-				_BitScanReverse(reinterpret_cast<unsigned long*>(&Result.z), vec.z);
-				_BitScanReverse(reinterpret_cast<unsigned long*>(&Result.w), vec.w);
+				_BitScanReverse(reinterpret_cast<unsigned long*>(&Result.x), v.x);
+				_BitScanReverse(reinterpret_cast<unsigned long*>(&Result.y), v.y);
+				_BitScanReverse(reinterpret_cast<unsigned long*>(&Result.z), v.z);
+				_BitScanReverse(reinterpret_cast<unsigned long*>(&Result.w), v.w);
 
 				return Result;
 			}
 		};
 #	endif//GLM_HAS_BITSCAN_WINDOWS
 }//namespace detail
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER int iround(genType x)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'iround' only accept floating-point inputs");
@@ -42,16 +42,16 @@ namespace detail
 		return static_cast<int>(x + static_cast<genType>(0.5));
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<int, P> iround(vecType<T, P> const& x)
+	template<glm::length_t L, typename T, precision P, template<glm::length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, int, P> iround(vecType<L, T, P> const& x)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'iround' only accept floating-point inputs");
-		assert(all(lessThanEqual(vecType<T, P>(0), x)));
+		assert(all(lessThanEqual(vecType<L, T, P>(0), x)));
 
-		return vecType<int, P>(x + static_cast<T>(0.5));
+		return vecType<L, int, P>(x + static_cast<T>(0.5));
 	}
 
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER uint uround(genType x)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'uround' only accept floating-point inputs");
@@ -60,12 +60,12 @@ namespace detail
 		return static_cast<uint>(x + static_cast<genType>(0.5));
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<uint, P> uround(vecType<T, P> const& x)
+	template<glm::length_t L, typename T, precision P, template<glm::length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, uint, P> uround(vecType<L, T, P> const& x)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'uround' only accept floating-point inputs");
-		assert(all(lessThanEqual(vecType<T, P>(0), x)));
+		assert(all(lessThanEqual(vecType<L, T, P>(0), x)));
 
-		return vecType<uint, P>(x + static_cast<T>(0.5));
+		return vecType<L, uint, P>(x + static_cast<T>(0.5));
 	}
 }//namespace glm
diff --git a/glm/gtc/matrix_access.hpp b/glm/gtc/matrix_access.hpp
index e4156ef4..ae3bd8d1 100644
--- a/glm/gtc/matrix_access.hpp
+++ b/glm/gtc/matrix_access.hpp
@@ -25,14 +25,14 @@ namespace glm
 
 	/// Get a specific row of a matrix.
 	/// @see gtc_matrix_access
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL typename genType::row_type row(
 		genType const & m,
 		length_t index);
 
 	/// Set a specific row to a matrix.
 	/// @see gtc_matrix_access
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL genType row(
 		genType const & m,
 		length_t index,
@@ -40,14 +40,14 @@ namespace glm
 
 	/// Get a specific column of a matrix.
 	/// @see gtc_matrix_access
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL typename genType::col_type column(
 		genType const & m,
 		length_t index);
 
 	/// Set a specific column to a matrix.
 	/// @see gtc_matrix_access
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL genType column(
 		genType const & m,
 		length_t index,
diff --git a/glm/gtc/matrix_access.inl b/glm/gtc/matrix_access.inl
index 831b9405..23ba348c 100644
--- a/glm/gtc/matrix_access.inl
+++ b/glm/gtc/matrix_access.inl
@@ -3,7 +3,7 @@
 
 namespace glm
 {
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER genType row
 	(
 		genType const & m,
@@ -19,7 +19,7 @@ namespace glm
 		return Result;
 	}
 
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER typename genType::row_type row
 	(
 		genType const & m,
@@ -34,7 +34,7 @@ namespace glm
 		return Result;
 	}
 
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER genType column
 	(
 		genType const & m,
@@ -49,7 +49,7 @@ namespace glm
 		return Result;
 	}
 
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER typename genType::col_type column
 	(
 		genType const & m,
diff --git a/glm/gtc/matrix_integer.hpp b/glm/gtc/matrix_integer.hpp
index fdc816d5..0f2c0d99 100644
--- a/glm/gtc/matrix_integer.hpp
+++ b/glm/gtc/matrix_integer.hpp
@@ -33,300 +33,300 @@ namespace glm
 
 	/// High-precision signed integer 2x2 matrix.
 	/// @see gtc_matrix_integer
-	typedef tmat2x2<int, highp>				highp_imat2;
+	typedef mat<2, 2, int, highp>				highp_imat2;
 
 	/// High-precision signed integer 3x3 matrix.
 	/// @see gtc_matrix_integer
-	typedef tmat3x3<int, highp>				highp_imat3;
+	typedef mat<3, 3, int, highp>				highp_imat3;
 
 	/// High-precision signed integer 4x4 matrix.
 	/// @see gtc_matrix_integer
-	typedef tmat4x4<int, highp>				highp_imat4;
+	typedef mat<4, 4, int, highp>				highp_imat4;
 
 	/// High-precision signed integer 2x2 matrix.
 	/// @see gtc_matrix_integer
-	typedef tmat2x2<int, highp>				highp_imat2x2;
+	typedef mat<2, 2, int, highp>				highp_imat2x2;
 
 	/// High-precision signed integer 2x3 matrix.
 	/// @see gtc_matrix_integer
-	typedef tmat2x3<int, highp>				highp_imat2x3;
+	typedef mat<2, 3, int, highp>				highp_imat2x3;
 
 	/// High-precision signed integer 2x4 matrix.
 	/// @see gtc_matrix_integer
-	typedef tmat2x4<int, highp>				highp_imat2x4;
+	typedef mat<2, 4, int, highp>				highp_imat2x4;
 
 	/// High-precision signed integer 3x2 matrix.
 	/// @see gtc_matrix_integer
-	typedef tmat3x2<int, highp>				highp_imat3x2;
+	typedef mat<3, 2, int, highp>				highp_imat3x2;
 
 	/// High-precision signed integer 3x3 matrix.
 	/// @see gtc_matrix_integer
-	typedef tmat3x3<int, highp>				highp_imat3x3;
+	typedef mat<3, 3, int, highp>				highp_imat3x3;
 
 	/// High-precision signed integer 3x4 matrix.
 	/// @see gtc_matrix_integer
-	typedef tmat3x4<int, highp>				highp_imat3x4;
+	typedef mat<3, 4, int, highp>				highp_imat3x4;
 
 	/// High-precision signed integer 4x2 matrix.
 	/// @see gtc_matrix_integer
-	typedef tmat4x2<int, highp>				highp_imat4x2;
+	typedef mat<4, 2, int, highp>				highp_imat4x2;
 
 	/// High-precision signed integer 4x3 matrix.
 	/// @see gtc_matrix_integer
-	typedef tmat4x3<int, highp>				highp_imat4x3;
+	typedef mat<4, 3, int, highp>				highp_imat4x3;
 
 	/// High-precision signed integer 4x4 matrix.
 	/// @see gtc_matrix_integer
-	typedef tmat4x4<int, highp>				highp_imat4x4;
+	typedef mat<4, 4, int, highp>				highp_imat4x4;
 
 
 	/// Medium-precision signed integer 2x2 matrix.
 	/// @see gtc_matrix_integer
-	typedef tmat2x2<int, mediump>			mediump_imat2;
+	typedef mat<2, 2, int, mediump>			mediump_imat2;
 
 	/// Medium-precision signed integer 3x3 matrix.
 	/// @see gtc_matrix_integer
-	typedef tmat3x3<int, mediump>			mediump_imat3;
+	typedef mat<3, 3, int, mediump>			mediump_imat3;
 
 	/// Medium-precision signed integer 4x4 matrix.
 	/// @see gtc_matrix_integer
-	typedef tmat4x4<int, mediump>			mediump_imat4;
+	typedef mat<4, 4, int, mediump>			mediump_imat4;
 
 
 	/// Medium-precision signed integer 2x2 matrix.
 	/// @see gtc_matrix_integer
-	typedef tmat2x2<int, mediump>			mediump_imat2x2;
+	typedef mat<2, 2, int, mediump>			mediump_imat2x2;
 
 	/// Medium-precision signed integer 2x3 matrix.
 	/// @see gtc_matrix_integer
-	typedef tmat2x3<int, mediump>			mediump_imat2x3;
+	typedef mat<2, 3, int, mediump>			mediump_imat2x3;
 
 	/// Medium-precision signed integer 2x4 matrix.
 	/// @see gtc_matrix_integer
-	typedef tmat2x4<int, mediump>			mediump_imat2x4;
+	typedef mat<2, 4, int, mediump>			mediump_imat2x4;
 
 	/// Medium-precision signed integer 3x2 matrix.
 	/// @see gtc_matrix_integer
-	typedef tmat3x2<int, mediump>			mediump_imat3x2;
+	typedef mat<3, 2, int, mediump>			mediump_imat3x2;
 
 	/// Medium-precision signed integer 3x3 matrix.
 	/// @see gtc_matrix_integer
-	typedef tmat3x3<int, mediump>			mediump_imat3x3;
+	typedef mat<3, 3, int, mediump>			mediump_imat3x3;
 
 	/// Medium-precision signed integer 3x4 matrix.
 	/// @see gtc_matrix_integer
-	typedef tmat3x4<int, mediump>			mediump_imat3x4;
+	typedef mat<3, 4, int, mediump>			mediump_imat3x4;
 
 	/// Medium-precision signed integer 4x2 matrix.
 	/// @see gtc_matrix_integer
-	typedef tmat4x2<int, mediump>			mediump_imat4x2;
+	typedef mat<4, 2, int, mediump>			mediump_imat4x2;
 
 	/// Medium-precision signed integer 4x3 matrix.
 	/// @see gtc_matrix_integer
-	typedef tmat4x3<int, mediump>			mediump_imat4x3;
+	typedef mat<4, 3, int, mediump>			mediump_imat4x3;
 
 	/// Medium-precision signed integer 4x4 matrix.
 	/// @see gtc_matrix_integer
-	typedef tmat4x4<int, mediump>			mediump_imat4x4;
+	typedef mat<4, 4, int, mediump>			mediump_imat4x4;
 
 
 	/// Low-precision signed integer 2x2 matrix.
 	/// @see gtc_matrix_integer
-	typedef tmat2x2<int, lowp>				lowp_imat2;
+	typedef mat<2, 2, int, lowp>				lowp_imat2;
 	
 	/// Low-precision signed integer 3x3 matrix.
 	/// @see gtc_matrix_integer
-	typedef tmat3x3<int, lowp>				lowp_imat3;
+	typedef mat<3, 3, int, lowp>				lowp_imat3;
 
 	/// Low-precision signed integer 4x4 matrix.
 	/// @see gtc_matrix_integer
-	typedef tmat4x4<int, lowp>				lowp_imat4;
+	typedef mat<4, 4, int, lowp>				lowp_imat4;
 
 
 	/// Low-precision signed integer 2x2 matrix.
 	/// @see gtc_matrix_integer
-	typedef tmat2x2<int, lowp>				lowp_imat2x2;
+	typedef mat<2, 2, int, lowp>				lowp_imat2x2;
 
 	/// Low-precision signed integer 2x3 matrix.
 	/// @see gtc_matrix_integer
-	typedef tmat2x3<int, lowp>				lowp_imat2x3;
+	typedef mat<2, 3, int, lowp>				lowp_imat2x3;
 
 	/// Low-precision signed integer 2x4 matrix.
 	/// @see gtc_matrix_integer
-	typedef tmat2x4<int, lowp>				lowp_imat2x4;
+	typedef mat<2, 4, int, lowp>				lowp_imat2x4;
 
 	/// Low-precision signed integer 3x2 matrix.
 	/// @see gtc_matrix_integer
-	typedef tmat3x2<int, lowp>				lowp_imat3x2;
+	typedef mat<3, 2, int, lowp>				lowp_imat3x2;
 
 	/// Low-precision signed integer 3x3 matrix.
 	/// @see gtc_matrix_integer
-	typedef tmat3x3<int, lowp>				lowp_imat3x3;
+	typedef mat<3, 3, int, lowp>				lowp_imat3x3;
 
 	/// Low-precision signed integer 3x4 matrix.
 	/// @see gtc_matrix_integer
-	typedef tmat3x4<int, lowp>				lowp_imat3x4;
+	typedef mat<3, 4, int, lowp>				lowp_imat3x4;
 
 	/// Low-precision signed integer 4x2 matrix.
 	/// @see gtc_matrix_integer
-	typedef tmat4x2<int, lowp>				lowp_imat4x2;
+	typedef mat<4, 2, int, lowp>				lowp_imat4x2;
 
 	/// Low-precision signed integer 4x3 matrix.
 	/// @see gtc_matrix_integer
-	typedef tmat4x3<int, lowp>				lowp_imat4x3;
+	typedef mat<4, 3, int, lowp>				lowp_imat4x3;
 
 	/// Low-precision signed integer 4x4 matrix.
 	/// @see gtc_matrix_integer
-	typedef tmat4x4<int, lowp>				lowp_imat4x4;
+	typedef mat<4, 4, int, lowp>				lowp_imat4x4;
 
 
 	/// High-precision unsigned integer 2x2 matrix.
 	/// @see gtc_matrix_integer
-	typedef tmat2x2<uint, highp>				highp_umat2;	
+	typedef mat<2, 2, uint, highp>				highp_umat2;	
 
 	/// High-precision unsigned integer 3x3 matrix.
 	/// @see gtc_matrix_integer
-	typedef tmat3x3<uint, highp>				highp_umat3;
+	typedef mat<3, 3, uint, highp>				highp_umat3;
 
 	/// High-precision unsigned integer 4x4 matrix.
 	/// @see gtc_matrix_integer
-	typedef tmat4x4<uint, highp>				highp_umat4;
+	typedef mat<4, 4, uint, highp>				highp_umat4;
 
 	/// High-precision unsigned integer 2x2 matrix.
 	/// @see gtc_matrix_integer
-	typedef tmat2x2<uint, highp>				highp_umat2x2;
+	typedef mat<2, 2, uint, highp>				highp_umat2x2;
 
 	/// High-precision unsigned integer 2x3 matrix.
 	/// @see gtc_matrix_integer
-	typedef tmat2x3<uint, highp>				highp_umat2x3;
+	typedef mat<2, 3, uint, highp>				highp_umat2x3;
 
 	/// High-precision unsigned integer 2x4 matrix.
 	/// @see gtc_matrix_integer
-	typedef tmat2x4<uint, highp>				highp_umat2x4;
+	typedef mat<2, 4, uint, highp>				highp_umat2x4;
 
 	/// High-precision unsigned integer 3x2 matrix.
 	/// @see gtc_matrix_integer
-	typedef tmat3x2<uint, highp>				highp_umat3x2;
+	typedef mat<3, 2, uint, highp>				highp_umat3x2;
 
 	/// High-precision unsigned integer 3x3 matrix.
 	/// @see gtc_matrix_integer
-	typedef tmat3x3<uint, highp>				highp_umat3x3;
+	typedef mat<3, 3, uint, highp>				highp_umat3x3;
 
 	/// High-precision unsigned integer 3x4 matrix.
 	/// @see gtc_matrix_integer
-	typedef tmat3x4<uint, highp>				highp_umat3x4;
+	typedef mat<3, 4, uint, highp>				highp_umat3x4;
 
 	/// High-precision unsigned integer 4x2 matrix.
 	/// @see gtc_matrix_integer
-	typedef tmat4x2<uint, highp>				highp_umat4x2;
+	typedef mat<4, 2, uint, highp>				highp_umat4x2;
 
 	/// High-precision unsigned integer 4x3 matrix.
 	/// @see gtc_matrix_integer
-	typedef tmat4x3<uint, highp>				highp_umat4x3;
+	typedef mat<4, 3, uint, highp>				highp_umat4x3;
 
 	/// High-precision unsigned integer 4x4 matrix.
 	/// @see gtc_matrix_integer
-	typedef tmat4x4<uint, highp>				highp_umat4x4;
+	typedef mat<4, 4, uint, highp>				highp_umat4x4;
 
 
 	/// Medium-precision unsigned integer 2x2 matrix.
 	/// @see gtc_matrix_integer
-	typedef tmat2x2<uint, mediump>			mediump_umat2;
+	typedef mat<2, 2, uint, mediump>			mediump_umat2;
 
 	/// Medium-precision unsigned integer 3x3 matrix.
 	/// @see gtc_matrix_integer
-	typedef tmat3x3<uint, mediump>			mediump_umat3;
+	typedef mat<3, 3, uint, mediump>			mediump_umat3;
 
 	/// Medium-precision unsigned integer 4x4 matrix.
 	/// @see gtc_matrix_integer
-	typedef tmat4x4<uint, mediump>			mediump_umat4;
+	typedef mat<4, 4, uint, mediump>			mediump_umat4;
 
 
 	/// Medium-precision unsigned integer 2x2 matrix.
 	/// @see gtc_matrix_integer
-	typedef tmat2x2<uint, mediump>			mediump_umat2x2;
+	typedef mat<2, 2, uint, mediump>			mediump_umat2x2;
 
 	/// Medium-precision unsigned integer 2x3 matrix.
 	/// @see gtc_matrix_integer
-	typedef tmat2x3<uint, mediump>			mediump_umat2x3;
+	typedef mat<2, 3, uint, mediump>			mediump_umat2x3;
 
 	/// Medium-precision unsigned integer 2x4 matrix.
 	/// @see gtc_matrix_integer
-	typedef tmat2x4<uint, mediump>			mediump_umat2x4;
+	typedef mat<2, 4, uint, mediump>			mediump_umat2x4;
 
 	/// Medium-precision unsigned integer 3x2 matrix.
 	/// @see gtc_matrix_integer
-	typedef tmat3x2<uint, mediump>			mediump_umat3x2;
+	typedef mat<3, 2, uint, mediump>			mediump_umat3x2;
 
 	/// Medium-precision unsigned integer 3x3 matrix.
 	/// @see gtc_matrix_integer
-	typedef tmat3x3<uint, mediump>			mediump_umat3x3;
+	typedef mat<3, 3, uint, mediump>			mediump_umat3x3;
 
 	/// Medium-precision unsigned integer 3x4 matrix.
 	/// @see gtc_matrix_integer
-	typedef tmat3x4<uint, mediump>			mediump_umat3x4;
+	typedef mat<3, 4, uint, mediump>			mediump_umat3x4;
 
 	/// Medium-precision unsigned integer 4x2 matrix.
 	/// @see gtc_matrix_integer
-	typedef tmat4x2<uint, mediump>			mediump_umat4x2;
+	typedef mat<4, 2, uint, mediump>			mediump_umat4x2;
 
 	/// Medium-precision unsigned integer 4x3 matrix.
 	/// @see gtc_matrix_integer
-	typedef tmat4x3<uint, mediump>			mediump_umat4x3;
+	typedef mat<4, 3, uint, mediump>			mediump_umat4x3;
 
 	/// Medium-precision unsigned integer 4x4 matrix.
 	/// @see gtc_matrix_integer
-	typedef tmat4x4<uint, mediump>			mediump_umat4x4;
+	typedef mat<4, 4, uint, mediump>			mediump_umat4x4;
 
 
 	/// Low-precision unsigned integer 2x2 matrix.
 	/// @see gtc_matrix_integer
-	typedef tmat2x2<uint, lowp>				lowp_umat2;
+	typedef mat<2, 2, uint, lowp>				lowp_umat2;
 	
 	/// Low-precision unsigned integer 3x3 matrix.
 	/// @see gtc_matrix_integer
-	typedef tmat3x3<uint, lowp>				lowp_umat3;
+	typedef mat<3, 3, uint, lowp>				lowp_umat3;
 
 	/// Low-precision unsigned integer 4x4 matrix.
 	/// @see gtc_matrix_integer
-	typedef tmat4x4<uint, lowp>				lowp_umat4;
+	typedef mat<4, 4, uint, lowp>				lowp_umat4;
 
 
 	/// Low-precision unsigned integer 2x2 matrix.
 	/// @see gtc_matrix_integer
-	typedef tmat2x2<uint, lowp>				lowp_umat2x2;
+	typedef mat<2, 2, uint, lowp>				lowp_umat2x2;
 
 	/// Low-precision unsigned integer 2x3 matrix.
 	/// @see gtc_matrix_integer
-	typedef tmat2x3<uint, lowp>				lowp_umat2x3;
+	typedef mat<2, 3, uint, lowp>				lowp_umat2x3;
 
 	/// Low-precision unsigned integer 2x4 matrix.
 	/// @see gtc_matrix_integer
-	typedef tmat2x4<uint, lowp>				lowp_umat2x4;
+	typedef mat<2, 4, uint, lowp>				lowp_umat2x4;
 
 	/// Low-precision unsigned integer 3x2 matrix.
 	/// @see gtc_matrix_integer
-	typedef tmat3x2<uint, lowp>				lowp_umat3x2;
+	typedef mat<3, 2, uint, lowp>				lowp_umat3x2;
 
 	/// Low-precision unsigned integer 3x3 matrix.
 	/// @see gtc_matrix_integer
-	typedef tmat3x3<uint, lowp>				lowp_umat3x3;
+	typedef mat<3, 3, uint, lowp>				lowp_umat3x3;
 
 	/// Low-precision unsigned integer 3x4 matrix.
 	/// @see gtc_matrix_integer
-	typedef tmat3x4<uint, lowp>				lowp_umat3x4;
+	typedef mat<3, 4, uint, lowp>				lowp_umat3x4;
 
 	/// Low-precision unsigned integer 4x2 matrix.
 	/// @see gtc_matrix_integer
-	typedef tmat4x2<uint, lowp>				lowp_umat4x2;
+	typedef mat<4, 2, uint, lowp>				lowp_umat4x2;
 
 	/// Low-precision unsigned integer 4x3 matrix.
 	/// @see gtc_matrix_integer
-	typedef tmat4x3<uint, lowp>				lowp_umat4x3;
+	typedef mat<4, 3, uint, lowp>				lowp_umat4x3;
 
 	/// Low-precision unsigned integer 4x4 matrix.
 	/// @see gtc_matrix_integer
-	typedef tmat4x4<uint, lowp>				lowp_umat4x4;
+	typedef mat<4, 4, uint, lowp>				lowp_umat4x4;
 
 #if(defined(GLM_PRECISION_HIGHP_INT))
 	typedef highp_imat2								imat2;
diff --git a/glm/gtc/matrix_inverse.hpp b/glm/gtc/matrix_inverse.hpp
index 589381d4..bbc73800 100644
--- a/glm/gtc/matrix_inverse.hpp
+++ b/glm/gtc/matrix_inverse.hpp
@@ -32,7 +32,7 @@ namespace glm
 	/// @param m Input matrix to invert.
 	/// @tparam genType Squared floating-point matrix: half, float or double. Inverse of matrix based of half-precision floating point value is highly innacurate.
 	/// @see gtc_matrix_inverse
-	template <typename genType> 
+	template<typename genType> 
 	GLM_FUNC_DECL genType affineInverse(genType const & m);
 
 	/// Compute the inverse transpose of a matrix.
@@ -40,7 +40,7 @@ namespace glm
 	/// @param m Input matrix to invert transpose.
 	/// @tparam genType Squared floating-point matrix: half, float or double. Inverse of matrix based of half-precision floating point value is highly innacurate.
 	/// @see gtc_matrix_inverse
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL genType inverseTranspose(genType const & m);
 
 	/// @}
diff --git a/glm/gtc/matrix_inverse.inl b/glm/gtc/matrix_inverse.inl
index 36c9bf7c..b1d9d900 100644
--- a/glm/gtc/matrix_inverse.inl
+++ b/glm/gtc/matrix_inverse.inl
@@ -3,35 +3,35 @@
 
 namespace glm
 {
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x3<T, P> affineInverse(tmat3x3<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, P> affineInverse(mat<3, 3, T, P> const & m)
 	{
-		tmat2x2<T, P> const Inv(inverse(tmat2x2<T, P>(m)));
+		mat<2, 2, T, P> const Inv(inverse(mat<2, 2, T, P>(m)));
 
-		return tmat3x3<T, P>(
-			tvec3<T, P>(Inv[0], static_cast<T>(0)),
-			tvec3<T, P>(Inv[1], static_cast<T>(0)),
-			tvec3<T, P>(-Inv * tvec2<T, P>(m[2]), static_cast<T>(1)));
+		return mat<3, 3, T, P>(
+			vec<3, T, P>(Inv[0], static_cast<T>(0)),
+			vec<3, T, P>(Inv[1], static_cast<T>(0)),
+			vec<3, T, P>(-Inv * vec<2, T, P>(m[2]), static_cast<T>(1)));
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> affineInverse(tmat4x4<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, P> affineInverse(mat<4, 4, T, P> const & m)
 	{
-		tmat3x3<T, P> const Inv(inverse(tmat3x3<T, P>(m)));
+		mat<3, 3, T, P> const Inv(inverse(mat<3, 3, T, P>(m)));
 
-		return tmat4x4<T, P>(
-			tvec4<T, P>(Inv[0], static_cast<T>(0)),
-			tvec4<T, P>(Inv[1], static_cast<T>(0)),
-			tvec4<T, P>(Inv[2], static_cast<T>(0)),
-			tvec4<T, P>(-Inv * tvec3<T, P>(m[3]), static_cast<T>(1)));
+		return mat<4, 4, T, P>(
+			vec<4, T, P>(Inv[0], static_cast<T>(0)),
+			vec<4, T, P>(Inv[1], static_cast<T>(0)),
+			vec<4, T, P>(Inv[2], static_cast<T>(0)),
+			vec<4, T, P>(-Inv * vec<3, T, P>(m[3]), static_cast<T>(1)));
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P> inverseTranspose(tmat2x2<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, P> inverseTranspose(mat<2, 2, T, P> const & m)
 	{
 		T Determinant = m[0][0] * m[1][1] - m[1][0] * m[0][1];
 
-		tmat2x2<T, P> Inverse(
+		mat<2, 2, T, P> Inverse(
 			+ m[1][1] / Determinant,
 			- m[0][1] / Determinant,
 			- m[1][0] / Determinant,
@@ -40,15 +40,15 @@ namespace glm
 		return Inverse;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x3<T, P> inverseTranspose(tmat3x3<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, P> inverseTranspose(mat<3, 3, T, P> const & m)
 	{
 		T Determinant =
 			+ m[0][0] * (m[1][1] * m[2][2] - m[1][2] * m[2][1])
 			- m[0][1] * (m[1][0] * m[2][2] - m[1][2] * m[2][0])
 			+ m[0][2] * (m[1][0] * m[2][1] - m[1][1] * m[2][0]);
 
-		tmat3x3<T, P> Inverse(uninitialize);
+		mat<3, 3, T, P> Inverse(uninitialize);
 		Inverse[0][0] = + (m[1][1] * m[2][2] - m[2][1] * m[1][2]);
 		Inverse[0][1] = - (m[1][0] * m[2][2] - m[2][0] * m[1][2]);
 		Inverse[0][2] = + (m[1][0] * m[2][1] - m[2][0] * m[1][1]);
@@ -63,8 +63,8 @@ namespace glm
 		return Inverse;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> inverseTranspose(tmat4x4<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, P> inverseTranspose(mat<4, 4, T, P> const & m)
 	{
 		T SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
 		T SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
@@ -86,7 +86,7 @@ namespace glm
 		T SubFactor17 = m[1][0] * m[2][2] - m[2][0] * m[1][2];
 		T SubFactor18 = m[1][0] * m[2][1] - m[2][0] * m[1][1];
 
-		tmat4x4<T, P> Inverse(uninitialize);
+		mat<4, 4, T, P> Inverse(uninitialize);
 		Inverse[0][0] = + (m[1][1] * SubFactor00 - m[1][2] * SubFactor01 + m[1][3] * SubFactor02);
 		Inverse[0][1] = - (m[1][0] * SubFactor00 - m[1][2] * SubFactor03 + m[1][3] * SubFactor04);
 		Inverse[0][2] = + (m[1][0] * SubFactor01 - m[1][1] * SubFactor03 + m[1][3] * SubFactor05);
diff --git a/glm/gtc/matrix_transform.hpp b/glm/gtc/matrix_transform.hpp
index 03a2a678..bbbbcfc2 100644
--- a/glm/gtc/matrix_transform.hpp
+++ b/glm/gtc/matrix_transform.hpp
@@ -52,12 +52,12 @@ namespace glm
 	/// // m[3][0] == 1.0f, m[3][1] == 1.0f, m[3][2] == 1.0f, m[3][3] == 1.0f
 	/// @endcode
 	/// @see gtc_matrix_transform
-	/// @see - translate(tmat4x4<T, P> const & m, T x, T y, T z)
-	/// @see - translate(tvec3<T, P> const & v)
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat4x4<T, P> translate(
-		tmat4x4<T, P> const & m,
-		tvec3<T, P> const & v);
+	/// @see - translate(mat<4, 4, T, P> const & m, T x, T y, T z)
+	/// @see - translate(vec<3, T, P> const & v)
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<4, 4, T, P> translate(
+		mat<4, 4, T, P> const& m,
+		vec<3, T, P> const & v);
 		
 	/// Builds a rotation 4 * 4 matrix created from an axis vector and an angle. 
 	/// 
@@ -66,13 +66,13 @@ namespace glm
 	/// @param axis Rotation axis, recommended to be normalized.
 	/// @tparam T Value type used to build the matrix. Supported: half, float or double.
 	/// @see gtc_matrix_transform
-	/// @see - rotate(tmat4x4<T, P> const & m, T angle, T x, T y, T z) 
-	/// @see - rotate(T angle, tvec3<T, P> const & v) 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat4x4<T, P> rotate(
-		tmat4x4<T, P> const & m,
+	/// @see - rotate(mat<4, 4, T, P> const & m, T angle, T x, T y, T z) 
+	/// @see - rotate(T angle, vec<3, T, P> const & v) 
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<4, 4, T, P> rotate(
+		mat<4, 4, T, P> const& m,
 		T angle,
-		tvec3<T, P> const & axis);
+		vec<3, T, P> const & axis);
 
 	/// Builds a scale 4 * 4 matrix created from 3 scalars. 
 	/// 
@@ -80,12 +80,12 @@ namespace glm
 	/// @param v Ratio of scaling for each axis.
 	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommended), float or double.
 	/// @see gtc_matrix_transform
-	/// @see - scale(tmat4x4<T, P> const & m, T x, T y, T z)
-	/// @see - scale(tvec3<T, P> const & v)
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat4x4<T, P> scale(
-		tmat4x4<T, P> const & m,
-		tvec3<T, P> const & v);
+	/// @see - scale(mat<4, 4, T, P> const & m, T x, T y, T z)
+	/// @see - scale(vec<3, T, P> const & v)
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<4, 4, T, P> scale(
+		mat<4, 4, T, P> const& m,
+		vec<3, T, P> const & v);
 
 	/// Creates a matrix for an orthographic parallel viewing volume, using the default handedness.
 	///
@@ -98,8 +98,8 @@ namespace glm
 	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double.
 	/// @see gtc_matrix_transform
 	/// @see - glm::ortho(T const & left, T const & right, T const & bottom, T const & top)
-	template <typename T>
-	GLM_FUNC_DECL tmat4x4<T, defaultp> ortho(
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> ortho(
 		T left,
 		T right,
 		T bottom,
@@ -118,8 +118,8 @@ namespace glm
 	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double.
 	/// @see gtc_matrix_transform
 	/// @see - glm::ortho(T const & left, T const & right, T const & bottom, T const & top)
-	template <typename T>
-	GLM_FUNC_DECL tmat4x4<T, defaultp> orthoLH(
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> orthoLH(
 		T left,
 		T right,
 		T bottom,
@@ -138,8 +138,8 @@ namespace glm
 	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double.
 	/// @see gtc_matrix_transform
 	/// @see - glm::ortho(T const & left, T const & right, T const & bottom, T const & top)
-	template <typename T>
-	GLM_FUNC_DECL tmat4x4<T, defaultp> orthoRH(
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> orthoRH(
 		T left,
 		T right,
 		T bottom,
@@ -156,8 +156,8 @@ namespace glm
 	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double.
 	/// @see gtc_matrix_transform
 	/// @see - glm::ortho(T const & left, T const & right, T const & bottom, T const & top, T const & zNear, T const & zFar)
-	template <typename T>
-	GLM_FUNC_DECL tmat4x4<T, defaultp> ortho(
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> ortho(
 		T left,
 		T right,
 		T bottom,
@@ -173,8 +173,8 @@ namespace glm
 	/// @param far
 	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double.
 	/// @see gtc_matrix_transform
-	template <typename T>
-	GLM_FUNC_DECL tmat4x4<T, defaultp> frustum(
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> frustum(
 		T left,
 		T right,
 		T bottom,
@@ -192,8 +192,8 @@ namespace glm
 	/// @param far
 	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double.
 	/// @see gtc_matrix_transform
-	template <typename T>
-	GLM_FUNC_DECL tmat4x4<T, defaultp> frustumLH(
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> frustumLH(
 		T left,
 		T right,
 		T bottom,
@@ -211,8 +211,8 @@ namespace glm
 	/// @param far
 	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double.
 	/// @see gtc_matrix_transform
-	template <typename T>
-	GLM_FUNC_DECL tmat4x4<T, defaultp> frustumRH(
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> frustumRH(
 		T left,
 		T right,
 		T bottom,
@@ -228,8 +228,8 @@ namespace glm
 	/// @param far Specifies the distance from the viewer to the far clipping plane (always positive).
 	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double.
 	/// @see gtc_matrix_transform
-	template <typename T>
-	GLM_FUNC_DECL tmat4x4<T, defaultp> perspective(
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> perspective(
 		T fovy,
 		T aspect,
 		T near,
@@ -243,8 +243,8 @@ namespace glm
 	/// @param far Specifies the distance from the viewer to the far clipping plane (always positive).
 	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double.
 	/// @see gtc_matrix_transform
-	template <typename T>
-	GLM_FUNC_DECL tmat4x4<T, defaultp> perspectiveRH(
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveRH(
 		T fovy,
 		T aspect,
 		T near,
@@ -258,8 +258,8 @@ namespace glm
 	/// @param far Specifies the distance from the viewer to the far clipping plane (always positive).
 	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double.
 	/// @see gtc_matrix_transform
-	template <typename T>
-	GLM_FUNC_DECL tmat4x4<T, defaultp> perspectiveLH(
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveLH(
 		T fovy,
 		T aspect,
 		T near,
@@ -274,8 +274,8 @@ namespace glm
 	/// @param far Specifies the distance from the viewer to the far clipping plane (always positive).
 	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double.
 	/// @see gtc_matrix_transform
-	template <typename T>
-	GLM_FUNC_DECL tmat4x4<T, defaultp> perspectiveFov(
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFov(
 		T fov,
 		T width,
 		T height,
@@ -291,8 +291,8 @@ namespace glm
 	/// @param far Specifies the distance from the viewer to the far clipping plane (always positive).
 	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double.
 	/// @see gtc_matrix_transform
-	template <typename T>
-	GLM_FUNC_DECL tmat4x4<T, defaultp> perspectiveFovRH(
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFovRH(
 		T fov,
 		T width,
 		T height,
@@ -308,8 +308,8 @@ namespace glm
 	/// @param far Specifies the distance from the viewer to the far clipping plane (always positive).
 	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double.
 	/// @see gtc_matrix_transform
-	template <typename T>
-	GLM_FUNC_DECL tmat4x4<T, defaultp> perspectiveFovLH(
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFovLH(
 		T fov,
 		T width,
 		T height,
@@ -323,8 +323,8 @@ namespace glm
 	/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
 	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double.
 	/// @see gtc_matrix_transform
-	template <typename T>
-	GLM_FUNC_DECL tmat4x4<T, defaultp> infinitePerspective(
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> infinitePerspective(
 		T fovy, T aspect, T near);
 
 	/// Creates a matrix for a left handed, symmetric perspective-view frustum with far plane at infinite.
@@ -334,8 +334,8 @@ namespace glm
 	/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
 	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double.
 	/// @see gtc_matrix_transform
-	template <typename T>
-	GLM_FUNC_DECL tmat4x4<T, defaultp> infinitePerspectiveLH(
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> infinitePerspectiveLH(
 		T fovy, T aspect, T near);
 
 	/// Creates a matrix for a right handed, symmetric perspective-view frustum with far plane at infinite.
@@ -345,8 +345,8 @@ namespace glm
 	/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
 	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double.
 	/// @see gtc_matrix_transform
-	template <typename T>
-	GLM_FUNC_DECL tmat4x4<T, defaultp> infinitePerspectiveRH(
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> infinitePerspectiveRH(
 		T fovy, T aspect, T near);
 
 	/// Creates a matrix for a symmetric perspective-view frustum with far plane at infinite for graphics hardware that doesn't support depth clamping.
@@ -356,8 +356,8 @@ namespace glm
 	/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
 	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double.
 	/// @see gtc_matrix_transform
-	template <typename T>
-	GLM_FUNC_DECL tmat4x4<T, defaultp> tweakedInfinitePerspective(
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> tweakedInfinitePerspective(
 		T fovy, T aspect, T near);
 
 	/// Creates a matrix for a symmetric perspective-view frustum with far plane at infinite for graphics hardware that doesn't support depth clamping.
@@ -368,8 +368,8 @@ namespace glm
 	/// @param ep 
 	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double.
 	/// @see gtc_matrix_transform
-	template <typename T>
-	GLM_FUNC_DECL tmat4x4<T, defaultp> tweakedInfinitePerspective(
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> tweakedInfinitePerspective(
 		T fovy, T aspect, T near, T ep);
 
 	/// Map the specified object coordinates (obj.x, obj.y, obj.z) into window coordinates.
@@ -382,12 +382,12 @@ namespace glm
 	/// @tparam T Native type used for the computation. Currently supported: half (not recommanded), float or double.
 	/// @tparam U Currently supported: Floating-point types and integer types.
 	/// @see gtc_matrix_transform
-	template <typename T, typename U, precision P>
-	GLM_FUNC_DECL tvec3<T, P> project(
-		tvec3<T, P> const & obj,
-		tmat4x4<T, P> const & model,
-		tmat4x4<T, P> const & proj,
-		tvec4<U, P> const & viewport);
+	template<typename T, typename U, precision P>
+	GLM_FUNC_DECL vec<3, T, P> project(
+		vec<3, T, P> const & obj,
+		mat<4, 4, T, P> const& model,
+		mat<4, 4, T, P> const& proj,
+		vec<4, U, P> const & viewport);
 
 	/// Map the specified window coordinates (win.x, win.y, win.z) into object coordinates.
 	///
@@ -399,12 +399,12 @@ namespace glm
 	/// @tparam T Native type used for the computation. Currently supported: half (not recommanded), float or double.
 	/// @tparam U Currently supported: Floating-point types and integer types.
 	/// @see gtc_matrix_transform
-	template <typename T, typename U, precision P>
-	GLM_FUNC_DECL tvec3<T, P> unProject(
-		tvec3<T, P> const & win,
-		tmat4x4<T, P> const & model,
-		tmat4x4<T, P> const & proj,
-		tvec4<U, P> const & viewport);
+	template<typename T, typename U, precision P>
+	GLM_FUNC_DECL vec<3, T, P> unProject(
+		vec<3, T, P> const & win,
+		mat<4, 4, T, P> const& model,
+		mat<4, 4, T, P> const& proj,
+		vec<4, U, P> const & viewport);
 
 	/// Define a picking region
 	///
@@ -414,11 +414,11 @@ namespace glm
 	/// @tparam T Native type used for the computation. Currently supported: half (not recommanded), float or double.
 	/// @tparam U Currently supported: Floating-point types and integer types.
 	/// @see gtc_matrix_transform
-	template <typename T, precision P, typename U>
-	GLM_FUNC_DECL tmat4x4<T, P> pickMatrix(
-		tvec2<T, P> const & center,
-		tvec2<T, P> const & delta,
-		tvec4<U, P> const & viewport);
+	template<typename T, precision P, typename U>
+	GLM_FUNC_DECL mat<4, 4, T, P> pickMatrix(
+		vec<2, T, P> const & center,
+		vec<2, T, P> const & delta,
+		vec<4, U, P> const & viewport);
 
 	/// Build a look at view matrix based on the default handedness.
 	///
@@ -427,11 +427,11 @@ namespace glm
 	/// @param up Normalized up vector, how the camera is oriented. Typically (0, 0, 1)
 	/// @see gtc_matrix_transform
 	/// @see - frustum(T const & left, T const & right, T const & bottom, T const & top, T const & nearVal, T const & farVal) frustum(T const & left, T const & right, T const & bottom, T const & top, T const & nearVal, T const & farVal)
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat4x4<T, P> lookAt(
-		tvec3<T, P> const & eye,
-		tvec3<T, P> const & center,
-		tvec3<T, P> const & up);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<4, 4, T, P> lookAt(
+		vec<3, T, P> const & eye,
+		vec<3, T, P> const & center,
+		vec<3, T, P> const & up);
 
 	/// Build a right handed look at view matrix.
 	///
@@ -440,11 +440,11 @@ namespace glm
 	/// @param up Normalized up vector, how the camera is oriented. Typically (0, 0, 1)
 	/// @see gtc_matrix_transform
 	/// @see - frustum(T const & left, T const & right, T const & bottom, T const & top, T const & nearVal, T const & farVal) frustum(T const & left, T const & right, T const & bottom, T const & top, T const & nearVal, T const & farVal)
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat4x4<T, P> lookAtRH(
-		tvec3<T, P> const & eye,
-		tvec3<T, P> const & center,
-		tvec3<T, P> const & up);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<4, 4, T, P> lookAtRH(
+		vec<3, T, P> const & eye,
+		vec<3, T, P> const & center,
+		vec<3, T, P> const & up);
 
 	/// Build a left handed look at view matrix.
 	///
@@ -453,11 +453,11 @@ namespace glm
 	/// @param up Normalized up vector, how the camera is oriented. Typically (0, 0, 1)
 	/// @see gtc_matrix_transform
 	/// @see - frustum(T const & left, T const & right, T const & bottom, T const & top, T const & nearVal, T const & farVal) frustum(T const & left, T const & right, T const & bottom, T const & top, T const & nearVal, T const & farVal)
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat4x4<T, P> lookAtLH(
-		tvec3<T, P> const & eye,
-		tvec3<T, P> const & center,
-		tvec3<T, P> const & up);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<4, 4, T, P> lookAtLH(
+		vec<3, T, P> const & eye,
+		vec<3, T, P> const & center,
+		vec<3, T, P> const & up);
 
 	/// @}
 }//namespace glm
diff --git a/glm/gtc/matrix_transform.inl b/glm/gtc/matrix_transform.inl
index b9ff418b..bf8aed6c 100644
--- a/glm/gtc/matrix_transform.inl
+++ b/glm/gtc/matrix_transform.inl
@@ -7,25 +7,25 @@
 
 namespace glm
 {
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> translate(tmat4x4<T, P> const & m, tvec3<T, P> const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, P> translate(mat<4, 4, T, P> const & m, vec<3, T, P> const & v)
 	{
-		tmat4x4<T, P> Result(m);
+		mat<4, 4, T, P> Result(m);
 		Result[3] = m[0] * v[0] + m[1] * v[1] + m[2] * v[2] + m[3];
 		return Result;
 	}
 	
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> rotate(tmat4x4<T, P> const & m, T angle, tvec3<T, P> const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, P> rotate(mat<4, 4, T, P> const & m, T angle, vec<3, T, P> const & v)
 	{
 		T const a = angle;
 		T const c = cos(a);
 		T const s = sin(a);
 
-		tvec3<T, P> axis(normalize(v));
-		tvec3<T, P> temp((T(1) - c) * axis);
+		vec<3, T, P> axis(normalize(v));
+		vec<3, T, P> temp((T(1) - c) * axis);
 
-		tmat4x4<T, P> Rotate(uninitialize);
+		mat<4, 4, T, P> Rotate(uninitialize);
 		Rotate[0][0] = c + temp[0] * axis[0];
 		Rotate[0][1] = temp[0] * axis[1] + s * axis[2];
 		Rotate[0][2] = temp[0] * axis[2] - s * axis[1];
@@ -38,7 +38,7 @@ namespace glm
 		Rotate[2][1] = temp[2] * axis[1] - s * axis[0];
 		Rotate[2][2] = c + temp[2] * axis[2];
 
-		tmat4x4<T, P> Result(uninitialize);
+		mat<4, 4, T, P> Result(uninitialize);
 		Result[0] = m[0] * Rotate[0][0] + m[1] * Rotate[0][1] + m[2] * Rotate[0][2];
 		Result[1] = m[0] * Rotate[1][0] + m[1] * Rotate[1][1] + m[2] * Rotate[1][2];
 		Result[2] = m[0] * Rotate[2][0] + m[1] * Rotate[2][1] + m[2] * Rotate[2][2];
@@ -46,15 +46,15 @@ namespace glm
 		return Result;
 	}
 		
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> rotate_slow(tmat4x4<T, P> const & m, T angle, tvec3<T, P> const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, P> rotate_slow(mat<4, 4, T, P> const & m, T angle, vec<3, T, P> const & v)
 	{
 		T const a = angle;
 		T const c = cos(a);
 		T const s = sin(a);
-		tmat4x4<T, P> Result;
+		mat<4, 4, T, P> Result;
 
-		tvec3<T, P> axis = normalize(v);
+		vec<3, T, P> axis = normalize(v);
 
 		Result[0][0] = c + (static_cast<T>(1) - c)      * axis.x     * axis.x;
 		Result[0][1] = (static_cast<T>(1) - c) * axis.x * axis.y + s * axis.z;
@@ -71,14 +71,14 @@ namespace glm
 		Result[2][2] = c + (static_cast<T>(1) - c) * axis.z * axis.z;
 		Result[2][3] = static_cast<T>(0);
 
-		Result[3] = tvec4<T, P>(0, 0, 0, 1);
+		Result[3] = vec<4, T, P>(0, 0, 0, 1);
 		return m * Result;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> scale(tmat4x4<T, P> const & m, tvec3<T, P> const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, P> scale(mat<4, 4, T, P> const & m, vec<3, T, P> const & v)
 	{
-		tmat4x4<T, P> Result(uninitialize);
+		mat<4, 4, T, P> Result(uninitialize);
 		Result[0] = m[0] * v[0];
 		Result[1] = m[1] * v[1];
 		Result[2] = m[2] * v[2];
@@ -86,18 +86,18 @@ namespace glm
 		return Result;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> scale_slow(tmat4x4<T, P> const & m, tvec3<T, P> const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, P> scale_slow(mat<4, 4, T, P> const & m, vec<3, T, P> const & v)
 	{
-		tmat4x4<T, P> Result(T(1));
+		mat<4, 4, T, P> Result(T(1));
 		Result[0][0] = v.x;
 		Result[1][1] = v.y;
 		Result[2][2] = v.z;
 		return m * Result;
 	}
 
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> ortho
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> ortho
 	(
 		T left, T right,
 		T bottom, T top,
@@ -111,15 +111,15 @@ namespace glm
 #		endif
 	}
 
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> orthoLH
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> orthoLH
 	(
 		T left, T right,
 		T bottom, T top,
 		T zNear, T zFar
 	)
 	{
-		tmat4x4<T, defaultp> Result(1);
+		mat<4, 4, T, defaultp> Result(1);
 		Result[0][0] = static_cast<T>(2) / (right - left);
 		Result[1][1] = static_cast<T>(2) / (top - bottom);
 		Result[3][0] = - (right + left) / (right - left);
@@ -136,15 +136,15 @@ namespace glm
 		return Result;
 	}
 
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> orthoRH
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> orthoRH
 	(
 		T left, T right,
 		T bottom, T top,
 		T zNear, T zFar
 	)
 	{
-		tmat4x4<T, defaultp> Result(1);
+		mat<4, 4, T, defaultp> Result(1);
 		Result[0][0] = static_cast<T>(2) / (right - left);
 		Result[1][1] = static_cast<T>(2) / (top - bottom);
 		Result[3][0] = - (right + left) / (right - left);
@@ -161,14 +161,14 @@ namespace glm
 		return Result;
 	}
 
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> ortho
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> ortho
 	(
 		T left, T right,
 		T bottom, T top
 	)
 	{
-		tmat4x4<T, defaultp> Result(static_cast<T>(1));
+		mat<4, 4, T, defaultp> Result(static_cast<T>(1));
 		Result[0][0] = static_cast<T>(2) / (right - left);
 		Result[1][1] = static_cast<T>(2) / (top - bottom);
 		Result[2][2] = - static_cast<T>(1);
@@ -177,8 +177,8 @@ namespace glm
 		return Result;
 	}
 
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> frustum
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> frustum
 	(
 		T left, T right,
 		T bottom, T top,
@@ -192,15 +192,15 @@ namespace glm
 #		endif
 	}
 
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> frustumLH
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> frustumLH
 	(
 		T left, T right,
 		T bottom, T top,
 		T nearVal, T farVal
 	)
 	{
-		tmat4x4<T, defaultp> Result(0);
+		mat<4, 4, T, defaultp> Result(0);
 		Result[0][0] = (static_cast<T>(2) * nearVal) / (right - left);
 		Result[1][1] = (static_cast<T>(2) * nearVal) / (top - bottom);
 		Result[2][0] = (right + left) / (right - left);
@@ -218,15 +218,15 @@ namespace glm
 		return Result;
 	}
 
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> frustumRH
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> frustumRH
 	(
 		T left, T right,
 		T bottom, T top,
 		T nearVal, T farVal
 	)
 	{
-		tmat4x4<T, defaultp> Result(0);
+		mat<4, 4, T, defaultp> Result(0);
 		Result[0][0] = (static_cast<T>(2) * nearVal) / (right - left);
 		Result[1][1] = (static_cast<T>(2) * nearVal) / (top - bottom);
 		Result[2][0] = (right + left) / (right - left);
@@ -244,8 +244,8 @@ namespace glm
 		return Result;
 	}
 
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> perspective(T fovy, T aspect, T zNear, T zFar)
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspective(T fovy, T aspect, T zNear, T zFar)
 	{
 #		if GLM_COORDINATE_SYSTEM == GLM_LEFT_HANDED
 			return perspectiveLH(fovy, aspect, zNear, zFar);
@@ -254,14 +254,14 @@ namespace glm
 #		endif
 	}
 
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> perspectiveRH(T fovy, T aspect, T zNear, T zFar)
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveRH(T fovy, T aspect, T zNear, T zFar)
 	{
 		assert(abs(aspect - std::numeric_limits<T>::epsilon()) > static_cast<T>(0));
 
 		T const tanHalfFovy = tan(fovy / static_cast<T>(2));
 
-		tmat4x4<T, defaultp> Result(static_cast<T>(0));
+		mat<4, 4, T, defaultp> Result(static_cast<T>(0));
 		Result[0][0] = static_cast<T>(1) / (aspect * tanHalfFovy);
 		Result[1][1] = static_cast<T>(1) / (tanHalfFovy);
 		Result[2][3] = - static_cast<T>(1);
@@ -277,14 +277,14 @@ namespace glm
 		return Result;
 	}
 	
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> perspectiveLH(T fovy, T aspect, T zNear, T zFar)
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveLH(T fovy, T aspect, T zNear, T zFar)
 	{
 		assert(abs(aspect - std::numeric_limits<T>::epsilon()) > static_cast<T>(0));
 
 		T const tanHalfFovy = tan(fovy / static_cast<T>(2));
 		
-		tmat4x4<T, defaultp> Result(static_cast<T>(0));
+		mat<4, 4, T, defaultp> Result(static_cast<T>(0));
 		Result[0][0] = static_cast<T>(1) / (aspect * tanHalfFovy);
 		Result[1][1] = static_cast<T>(1) / (tanHalfFovy);
 		Result[2][3] = static_cast<T>(1);
@@ -300,8 +300,8 @@ namespace glm
 		return Result;
 	}
 
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> perspectiveFov(T fov, T width, T height, T zNear, T zFar)
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveFov(T fov, T width, T height, T zNear, T zFar)
 	{
 #		if GLM_COORDINATE_SYSTEM == GLM_LEFT_HANDED
 			return perspectiveFovLH(fov, width, height, zNear, zFar);
@@ -310,8 +310,8 @@ namespace glm
 #		endif
 	}
 
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> perspectiveFovRH(T fov, T width, T height, T zNear, T zFar)
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveFovRH(T fov, T width, T height, T zNear, T zFar)
 	{
 		assert(width > static_cast<T>(0));
 		assert(height > static_cast<T>(0));
@@ -321,7 +321,7 @@ namespace glm
 		T const h = glm::cos(static_cast<T>(0.5) * rad) / glm::sin(static_cast<T>(0.5) * rad);
 		T const w = h * height / width; ///todo max(width , Height) / min(width , Height)?
 
-		tmat4x4<T, defaultp> Result(static_cast<T>(0));
+		mat<4, 4, T, defaultp> Result(static_cast<T>(0));
 		Result[0][0] = w;
 		Result[1][1] = h;
 		Result[2][3] = - static_cast<T>(1);
@@ -337,8 +337,8 @@ namespace glm
 		return Result;
 	}
 
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> perspectiveFovLH(T fov, T width, T height, T zNear, T zFar)
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveFovLH(T fov, T width, T height, T zNear, T zFar)
 	{
 		assert(width > static_cast<T>(0));
 		assert(height > static_cast<T>(0));
@@ -348,7 +348,7 @@ namespace glm
 		T const h = glm::cos(static_cast<T>(0.5) * rad) / glm::sin(static_cast<T>(0.5) * rad);
 		T const w = h * height / width; ///todo max(width , Height) / min(width , Height)?
 
-		tmat4x4<T, defaultp> Result(static_cast<T>(0));
+		mat<4, 4, T, defaultp> Result(static_cast<T>(0));
 		Result[0][0] = w;
 		Result[1][1] = h;
 		Result[2][3] = static_cast<T>(1);
@@ -364,8 +364,8 @@ namespace glm
 		return Result;
 	}
 
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> infinitePerspective(T fovy, T aspect, T zNear)
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> infinitePerspective(T fovy, T aspect, T zNear)
 	{
 #		if GLM_COORDINATE_SYSTEM == GLM_LEFT_HANDED
 			return infinitePerspectiveLH(fovy, aspect, zNear);
@@ -374,8 +374,8 @@ namespace glm
 #		endif
 	}
 
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> infinitePerspectiveRH(T fovy, T aspect, T zNear)
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> infinitePerspectiveRH(T fovy, T aspect, T zNear)
 	{
 		T const range = tan(fovy / static_cast<T>(2)) * zNear;
 		T const left = -range * aspect;
@@ -383,7 +383,7 @@ namespace glm
 		T const bottom = -range;
 		T const top = range;
 
-		tmat4x4<T, defaultp> Result(static_cast<T>(0));
+		mat<4, 4, T, defaultp> Result(static_cast<T>(0));
 		Result[0][0] = (static_cast<T>(2) * zNear) / (right - left);
 		Result[1][1] = (static_cast<T>(2) * zNear) / (top - bottom);
 		Result[2][2] = - static_cast<T>(1);
@@ -392,8 +392,8 @@ namespace glm
 		return Result;
 	}
 
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> infinitePerspectiveLH(T fovy, T aspect, T zNear)
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> infinitePerspectiveLH(T fovy, T aspect, T zNear)
 	{
 		T const range = tan(fovy / static_cast<T>(2)) * zNear;
 		T const left = -range * aspect;
@@ -401,7 +401,7 @@ namespace glm
 		T const bottom = -range;
 		T const top = range;
 
-		tmat4x4<T, defaultp> Result(T(0));
+		mat<4, 4, T, defaultp> Result(T(0));
 		Result[0][0] = (static_cast<T>(2) * zNear) / (right - left);
 		Result[1][1] = (static_cast<T>(2) * zNear) / (top - bottom);
 		Result[2][2] = static_cast<T>(1);
@@ -411,8 +411,8 @@ namespace glm
 	}
 
 	// Infinite projection matrix: http://www.terathon.com/gdc07_lengyel.pdf
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> tweakedInfinitePerspective(T fovy, T aspect, T zNear, T ep)
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> tweakedInfinitePerspective(T fovy, T aspect, T zNear, T ep)
 	{
 		T const range = tan(fovy / static_cast<T>(2)) * zNear;	
 		T const left = -range * aspect;
@@ -420,7 +420,7 @@ namespace glm
 		T const bottom = -range;
 		T const top = range;
 
-		tmat4x4<T, defaultp> Result(static_cast<T>(0));
+		mat<4, 4, T, defaultp> Result(static_cast<T>(0));
 		Result[0][0] = (static_cast<T>(2) * zNear) / (right - left);
 		Result[1][1] = (static_cast<T>(2) * zNear) / (top - bottom);
 		Result[2][2] = ep - static_cast<T>(1);
@@ -429,22 +429,22 @@ namespace glm
 		return Result;
 	}
 
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> tweakedInfinitePerspective(T fovy, T aspect, T zNear)
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> tweakedInfinitePerspective(T fovy, T aspect, T zNear)
 	{
 		return tweakedInfinitePerspective(fovy, aspect, zNear, epsilon<T>());
 	}
 
-	template <typename T, typename U, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> project
+	template<typename T, typename U, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> project
 	(
-		tvec3<T, P> const & obj,
-		tmat4x4<T, P> const & model,
-		tmat4x4<T, P> const & proj,
-		tvec4<U, P> const & viewport
+		vec<3, T, P> const & obj,
+		mat<4, 4, T, P> const& model,
+		mat<4, 4, T, P> const& proj,
+		vec<4, U, P> const & viewport
 	)
 	{
-		tvec4<T, P> tmp = tvec4<T, P>(obj, static_cast<T>(1));
+		vec<4, T, P> tmp = vec<4, T, P>(obj, static_cast<T>(1));
 		tmp = model * tmp;
 		tmp = proj * tmp;
 
@@ -458,21 +458,21 @@ namespace glm
 		tmp[0] = tmp[0] * T(viewport[2]) + T(viewport[0]);
 		tmp[1] = tmp[1] * T(viewport[3]) + T(viewport[1]);
 
-		return tvec3<T, P>(tmp);
+		return vec<3, T, P>(tmp);
 	}
 
-	template <typename T, typename U, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> unProject
+	template<typename T, typename U, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> unProject
 	(
-		tvec3<T, P> const & win,
-		tmat4x4<T, P> const & model,
-		tmat4x4<T, P> const & proj,
-		tvec4<U, P> const & viewport
+		vec<3, T, P> const & win,
+		mat<4, 4, T, P> const& model,
+		mat<4, 4, T, P> const& proj,
+		vec<4, U, P> const & viewport
 	)
 	{
-		tmat4x4<T, P> Inverse = inverse(proj * model);
+		mat<4, 4, T, P> Inverse = inverse(proj * model);
 
-		tvec4<T, P> tmp = tvec4<T, P>(win, T(1));
+		vec<4, T, P> tmp = vec<4, T, P>(win, T(1));
 		tmp.x = (tmp.x - T(viewport[0])) / T(viewport[2]);
 		tmp.y = (tmp.y - T(viewport[1])) / T(viewport[3]);
 #		if GLM_DEPTH_CLIP_SPACE == GLM_DEPTH_ZERO_TO_ONE
@@ -482,33 +482,33 @@ namespace glm
 			tmp = tmp * static_cast<T>(2) - static_cast<T>(1);
 #		endif
 
-		tvec4<T, P> obj = Inverse * tmp;
+		vec<4, T, P> obj = Inverse * tmp;
 		obj /= obj.w;
 
-		return tvec3<T, P>(obj);
+		return vec<3, T, P>(obj);
 	}
 
-	template <typename T, precision P, typename U>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> pickMatrix(tvec2<T, P> const & center, tvec2<T, P> const & delta, tvec4<U, P> const & viewport)
+	template<typename T, precision P, typename U>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, P> pickMatrix(vec<2, T, P> const & center, vec<2, T, P> const & delta, vec<4, U, P> const & viewport)
 	{
 		assert(delta.x > static_cast<T>(0) && delta.y > static_cast<T>(0));
-		tmat4x4<T, P> Result(static_cast<T>(1));
+		mat<4, 4, T, P> Result(static_cast<T>(1));
 
 		if(!(delta.x > static_cast<T>(0) && delta.y > static_cast<T>(0)))
 			return Result; // Error
 
-		tvec3<T, P> Temp(
+		vec<3, T, P> Temp(
 			(static_cast<T>(viewport[2]) - static_cast<T>(2) * (center.x - static_cast<T>(viewport[0]))) / delta.x,
 			(static_cast<T>(viewport[3]) - static_cast<T>(2) * (center.y - static_cast<T>(viewport[1]))) / delta.y,
 			static_cast<T>(0));
 
 		// Translate and scale the picked region to the entire window
 		Result = translate(Result, Temp);
-		return scale(Result, tvec3<T, P>(static_cast<T>(viewport[2]) / delta.x, static_cast<T>(viewport[3]) / delta.y, static_cast<T>(1)));
+		return scale(Result, vec<3, T, P>(static_cast<T>(viewport[2]) / delta.x, static_cast<T>(viewport[3]) / delta.y, static_cast<T>(1)));
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> lookAt(tvec3<T, P> const & eye, tvec3<T, P> const & center, tvec3<T, P> const & up)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, P> lookAt(vec<3, T, P> const & eye, vec<3, T, P> const & center, vec<3, T, P> const & up)
 	{
 #		if GLM_COORDINATE_SYSTEM == GLM_LEFT_HANDED
 			return lookAtLH(eye, center, up);
@@ -517,19 +517,19 @@ namespace glm
 #		endif
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> lookAtRH
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, P> lookAtRH
 	(
-		tvec3<T, P> const & eye,
-		tvec3<T, P> const & center,
-		tvec3<T, P> const & up
+		vec<3, T, P> const & eye,
+		vec<3, T, P> const & center,
+		vec<3, T, P> const & up
 	)
 	{
-		tvec3<T, P> const f(normalize(center - eye));
-		tvec3<T, P> const s(normalize(cross(f, up)));
-		tvec3<T, P> const u(cross(s, f));
+		vec<3, T, P> const f(normalize(center - eye));
+		vec<3, T, P> const s(normalize(cross(f, up)));
+		vec<3, T, P> const u(cross(s, f));
 
-		tmat4x4<T, P> Result(1);
+		mat<4, 4, T, P> Result(1);
 		Result[0][0] = s.x;
 		Result[1][0] = s.y;
 		Result[2][0] = s.z;
@@ -545,19 +545,19 @@ namespace glm
 		return Result;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> lookAtLH
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, P> lookAtLH
 	(
-		tvec3<T, P> const & eye,
-		tvec3<T, P> const & center,
-		tvec3<T, P> const & up
+		vec<3, T, P> const & eye,
+		vec<3, T, P> const & center,
+		vec<3, T, P> const & up
 	)
 	{
-		tvec3<T, P> const f(normalize(center - eye));
-		tvec3<T, P> const s(normalize(cross(up, f)));
-		tvec3<T, P> const u(cross(f, s));
+		vec<3, T, P> const f(normalize(center - eye));
+		vec<3, T, P> const s(normalize(cross(up, f)));
+		vec<3, T, P> const u(cross(f, s));
 
-		tmat4x4<T, P> Result(1);
+		mat<4, 4, T, P> Result(1);
 		Result[0][0] = s.x;
 		Result[1][0] = s.y;
 		Result[2][0] = s.z;
diff --git a/glm/gtc/noise.hpp b/glm/gtc/noise.hpp
index aec4f18d..870c5fbc 100644
--- a/glm/gtc/noise.hpp
+++ b/glm/gtc/noise.hpp
@@ -37,22 +37,22 @@ namespace glm
 
 	/// Classic perlin noise.
 	/// @see gtc_noise
-	template <typename T, precision P, template<typename, precision> class vecType>
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
 	GLM_FUNC_DECL T perlin(
-		vecType<T, P> const & p);
+		vecType<L, T, P> const& p);
 		
 	/// Periodic perlin noise.
 	/// @see gtc_noise
-	template <typename T, precision P, template<typename, precision> class vecType>
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
 	GLM_FUNC_DECL T perlin(
-		vecType<T, P> const & p,
-		vecType<T, P> const & rep);
+		vecType<L, T, P> const& p,
+		vecType<L, T, P> const& rep);
 
 	/// Simplex noise.
 	/// @see gtc_noise
-	template <typename T, precision P, template<typename, precision> class vecType>
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
 	GLM_FUNC_DECL T simplex(
-		vecType<T, P> const & p);
+		vecType<L, T, P> const& p);
 
 	/// @}
 }//namespace glm
diff --git a/glm/gtc/noise.inl b/glm/gtc/noise.inl
index 4f2731c4..d3a676f2 100644
--- a/glm/gtc/noise.inl
+++ b/glm/gtc/noise.inl
@@ -9,635 +9,635 @@
 namespace glm{
 namespace gtc
 {
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> grad4(T const & j, tvec4<T, P> const & ip)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, T, P> grad4(T const & j, vec<4, T, P> const & ip)
 	{
-		tvec3<T, P> pXYZ = floor(fract(tvec3<T, P>(j) * tvec3<T, P>(ip)) * T(7)) * ip[2] - T(1);
-		T pW = static_cast<T>(1.5) - dot(abs(pXYZ), tvec3<T, P>(1));
-		tvec4<T, P> s = tvec4<T, P>(lessThan(tvec4<T, P>(pXYZ, pW), tvec4<T, P>(0.0)));
-		pXYZ = pXYZ + (tvec3<T, P>(s) * T(2) - T(1)) * s.w; 
-		return tvec4<T, P>(pXYZ, pW);
+		vec<3, T, P> pXYZ = floor(fract(vec<3, T, P>(j) * vec<3, T, P>(ip)) * T(7)) * ip[2] - T(1);
+		T pW = static_cast<T>(1.5) - dot(abs(pXYZ), vec<3, T, P>(1));
+		vec<4, T, P> s = vec<4, T, P>(lessThan(vec<4, T, P>(pXYZ, pW), vec<4, T, P>(0.0)));
+		pXYZ = pXYZ + (vec<3, T, P>(s) * T(2) - T(1)) * s.w; 
+		return vec<4, T, P>(pXYZ, pW);
 	}
 }//namespace gtc
 
 	// Classic Perlin noise
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER T perlin(tvec2<T, P> const & Position)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER T perlin(vec<2, T, P> const & Position)
 	{
-		tvec4<T, P> Pi = glm::floor(tvec4<T, P>(Position.x, Position.y, Position.x, Position.y)) + tvec4<T, P>(0.0, 0.0, 1.0, 1.0);
-		tvec4<T, P> Pf = glm::fract(tvec4<T, P>(Position.x, Position.y, Position.x, Position.y)) - tvec4<T, P>(0.0, 0.0, 1.0, 1.0);
-		Pi = mod(Pi, tvec4<T, P>(289)); // To avoid truncation effects in permutation
-		tvec4<T, P> ix(Pi.x, Pi.z, Pi.x, Pi.z);
-		tvec4<T, P> iy(Pi.y, Pi.y, Pi.w, Pi.w);
-		tvec4<T, P> fx(Pf.x, Pf.z, Pf.x, Pf.z);
-		tvec4<T, P> fy(Pf.y, Pf.y, Pf.w, Pf.w);
+		vec<4, T, P> Pi = glm::floor(vec<4, T, P>(Position.x, Position.y, Position.x, Position.y)) + vec<4, T, P>(0.0, 0.0, 1.0, 1.0);
+		vec<4, T, P> Pf = glm::fract(vec<4, T, P>(Position.x, Position.y, Position.x, Position.y)) - vec<4, T, P>(0.0, 0.0, 1.0, 1.0);
+		Pi = mod(Pi, vec<4, T, P>(289)); // To avoid truncation effects in permutation
+		vec<4, T, P> ix(Pi.x, Pi.z, Pi.x, Pi.z);
+		vec<4, T, P> iy(Pi.y, Pi.y, Pi.w, Pi.w);
+		vec<4, T, P> fx(Pf.x, Pf.z, Pf.x, Pf.z);
+		vec<4, T, P> fy(Pf.y, Pf.y, Pf.w, Pf.w);
 
-		tvec4<T, P> i = detail::permute(detail::permute(ix) + iy);
+		vec<4, T, P> i = detail::permute(detail::permute(ix) + iy);
 
-		tvec4<T, P> gx = static_cast<T>(2) * glm::fract(i / T(41)) - T(1);
-		tvec4<T, P> gy = glm::abs(gx) - T(0.5);
-		tvec4<T, P> tx = glm::floor(gx + T(0.5));
+		vec<4, T, P> gx = static_cast<T>(2) * glm::fract(i / T(41)) - T(1);
+		vec<4, T, P> gy = glm::abs(gx) - T(0.5);
+		vec<4, T, P> tx = glm::floor(gx + T(0.5));
 		gx = gx - tx;
 
-		tvec2<T, P> g00(gx.x, gy.x);
-		tvec2<T, P> g10(gx.y, gy.y);
-		tvec2<T, P> g01(gx.z, gy.z);
-		tvec2<T, P> g11(gx.w, gy.w);
+		vec<2, T, P> g00(gx.x, gy.x);
+		vec<2, T, P> g10(gx.y, gy.y);
+		vec<2, T, P> g01(gx.z, gy.z);
+		vec<2, T, P> g11(gx.w, gy.w);
 
-		tvec4<T, P> norm = detail::taylorInvSqrt(tvec4<T, P>(dot(g00, g00), dot(g01, g01), dot(g10, g10), dot(g11, g11)));
+		vec<4, T, P> norm = detail::taylorInvSqrt(vec<4, T, P>(dot(g00, g00), dot(g01, g01), dot(g10, g10), dot(g11, g11)));
 		g00 *= norm.x;
 		g01 *= norm.y;
 		g10 *= norm.z;
 		g11 *= norm.w;
 
-		T n00 = dot(g00, tvec2<T, P>(fx.x, fy.x));
-		T n10 = dot(g10, tvec2<T, P>(fx.y, fy.y));
-		T n01 = dot(g01, tvec2<T, P>(fx.z, fy.z));
-		T n11 = dot(g11, tvec2<T, P>(fx.w, fy.w));
+		T n00 = dot(g00, vec<2, T, P>(fx.x, fy.x));
+		T n10 = dot(g10, vec<2, T, P>(fx.y, fy.y));
+		T n01 = dot(g01, vec<2, T, P>(fx.z, fy.z));
+		T n11 = dot(g11, vec<2, T, P>(fx.w, fy.w));
 
-		tvec2<T, P> fade_xy = detail::fade(tvec2<T, P>(Pf.x, Pf.y));
-		tvec2<T, P> n_x = mix(tvec2<T, P>(n00, n01), tvec2<T, P>(n10, n11), fade_xy.x);
+		vec<2, T, P> fade_xy = detail::fade(vec<2, T, P>(Pf.x, Pf.y));
+		vec<2, T, P> n_x = mix(vec<2, T, P>(n00, n01), vec<2, T, P>(n10, n11), fade_xy.x);
 		T n_xy = mix(n_x.x, n_x.y, fade_xy.y);
 		return T(2.3) * n_xy;
 	}
 
 	// Classic Perlin noise
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER T perlin(tvec3<T, P> const & Position)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER T perlin(vec<3, T, P> const & Position)
 	{
-		tvec3<T, P> Pi0 = floor(Position); // Integer part for indexing
-		tvec3<T, P> Pi1 = Pi0 + T(1); // Integer part + 1
+		vec<3, T, P> Pi0 = floor(Position); // Integer part for indexing
+		vec<3, T, P> Pi1 = Pi0 + T(1); // Integer part + 1
 		Pi0 = detail::mod289(Pi0);
 		Pi1 = detail::mod289(Pi1);
-		tvec3<T, P> Pf0 = fract(Position); // Fractional part for interpolation
-		tvec3<T, P> Pf1 = Pf0 - T(1); // Fractional part - 1.0
-		tvec4<T, P> ix(Pi0.x, Pi1.x, Pi0.x, Pi1.x);
-		tvec4<T, P> iy = tvec4<T, P>(tvec2<T, P>(Pi0.y), tvec2<T, P>(Pi1.y));
-		tvec4<T, P> iz0(Pi0.z);
-		tvec4<T, P> iz1(Pi1.z);
+		vec<3, T, P> Pf0 = fract(Position); // Fractional part for interpolation
+		vec<3, T, P> Pf1 = Pf0 - T(1); // Fractional part - 1.0
+		vec<4, T, P> ix(Pi0.x, Pi1.x, Pi0.x, Pi1.x);
+		vec<4, T, P> iy = vec<4, T, P>(vec<2, T, P>(Pi0.y), vec<2, T, P>(Pi1.y));
+		vec<4, T, P> iz0(Pi0.z);
+		vec<4, T, P> iz1(Pi1.z);
 
-		tvec4<T, P> ixy = detail::permute(detail::permute(ix) + iy);
-		tvec4<T, P> ixy0 = detail::permute(ixy + iz0);
-		tvec4<T, P> ixy1 = detail::permute(ixy + iz1);
+		vec<4, T, P> ixy = detail::permute(detail::permute(ix) + iy);
+		vec<4, T, P> ixy0 = detail::permute(ixy + iz0);
+		vec<4, T, P> ixy1 = detail::permute(ixy + iz1);
 
-		tvec4<T, P> gx0 = ixy0 * T(1.0 / 7.0);
-		tvec4<T, P> gy0 = fract(floor(gx0) * T(1.0 / 7.0)) - T(0.5);
+		vec<4, T, P> gx0 = ixy0 * T(1.0 / 7.0);
+		vec<4, T, P> gy0 = fract(floor(gx0) * T(1.0 / 7.0)) - T(0.5);
 		gx0 = fract(gx0);
-		tvec4<T, P> gz0 = tvec4<T, P>(0.5) - abs(gx0) - abs(gy0);
-		tvec4<T, P> sz0 = step(gz0, tvec4<T, P>(0.0));
+		vec<4, T, P> gz0 = vec<4, T, P>(0.5) - abs(gx0) - abs(gy0);
+		vec<4, T, P> sz0 = step(gz0, vec<4, T, P>(0.0));
 		gx0 -= sz0 * (step(T(0), gx0) - T(0.5));
 		gy0 -= sz0 * (step(T(0), gy0) - T(0.5));
 
-		tvec4<T, P> gx1 = ixy1 * T(1.0 / 7.0);
-		tvec4<T, P> gy1 = fract(floor(gx1) * T(1.0 / 7.0)) - T(0.5);
+		vec<4, T, P> gx1 = ixy1 * T(1.0 / 7.0);
+		vec<4, T, P> gy1 = fract(floor(gx1) * T(1.0 / 7.0)) - T(0.5);
 		gx1 = fract(gx1);
-		tvec4<T, P> gz1 = tvec4<T, P>(0.5) - abs(gx1) - abs(gy1);
-		tvec4<T, P> sz1 = step(gz1, tvec4<T, P>(0.0));
+		vec<4, T, P> gz1 = vec<4, T, P>(0.5) - abs(gx1) - abs(gy1);
+		vec<4, T, P> sz1 = step(gz1, vec<4, T, P>(0.0));
 		gx1 -= sz1 * (step(T(0), gx1) - T(0.5));
 		gy1 -= sz1 * (step(T(0), gy1) - T(0.5));
 
-		tvec3<T, P> g000(gx0.x, gy0.x, gz0.x);
-		tvec3<T, P> g100(gx0.y, gy0.y, gz0.y);
-		tvec3<T, P> g010(gx0.z, gy0.z, gz0.z);
-		tvec3<T, P> g110(gx0.w, gy0.w, gz0.w);
-		tvec3<T, P> g001(gx1.x, gy1.x, gz1.x);
-		tvec3<T, P> g101(gx1.y, gy1.y, gz1.y);
-		tvec3<T, P> g011(gx1.z, gy1.z, gz1.z);
-		tvec3<T, P> g111(gx1.w, gy1.w, gz1.w);
+		vec<3, T, P> g000(gx0.x, gy0.x, gz0.x);
+		vec<3, T, P> g100(gx0.y, gy0.y, gz0.y);
+		vec<3, T, P> g010(gx0.z, gy0.z, gz0.z);
+		vec<3, T, P> g110(gx0.w, gy0.w, gz0.w);
+		vec<3, T, P> g001(gx1.x, gy1.x, gz1.x);
+		vec<3, T, P> g101(gx1.y, gy1.y, gz1.y);
+		vec<3, T, P> g011(gx1.z, gy1.z, gz1.z);
+		vec<3, T, P> g111(gx1.w, gy1.w, gz1.w);
 
-		tvec4<T, P> norm0 = detail::taylorInvSqrt(tvec4<T, P>(dot(g000, g000), dot(g010, g010), dot(g100, g100), dot(g110, g110)));
+		vec<4, T, P> norm0 = detail::taylorInvSqrt(vec<4, T, P>(dot(g000, g000), dot(g010, g010), dot(g100, g100), dot(g110, g110)));
 		g000 *= norm0.x;
 		g010 *= norm0.y;
 		g100 *= norm0.z;
 		g110 *= norm0.w;
-		tvec4<T, P> norm1 = detail::taylorInvSqrt(tvec4<T, P>(dot(g001, g001), dot(g011, g011), dot(g101, g101), dot(g111, g111)));
+		vec<4, T, P> norm1 = detail::taylorInvSqrt(vec<4, T, P>(dot(g001, g001), dot(g011, g011), dot(g101, g101), dot(g111, g111)));
 		g001 *= norm1.x;
 		g011 *= norm1.y;
 		g101 *= norm1.z;
 		g111 *= norm1.w;
 
 		T n000 = dot(g000, Pf0);
-		T n100 = dot(g100, tvec3<T, P>(Pf1.x, Pf0.y, Pf0.z));
-		T n010 = dot(g010, tvec3<T, P>(Pf0.x, Pf1.y, Pf0.z));
-		T n110 = dot(g110, tvec3<T, P>(Pf1.x, Pf1.y, Pf0.z));
-		T n001 = dot(g001, tvec3<T, P>(Pf0.x, Pf0.y, Pf1.z));
-		T n101 = dot(g101, tvec3<T, P>(Pf1.x, Pf0.y, Pf1.z));
-		T n011 = dot(g011, tvec3<T, P>(Pf0.x, Pf1.y, Pf1.z));
+		T n100 = dot(g100, vec<3, T, P>(Pf1.x, Pf0.y, Pf0.z));
+		T n010 = dot(g010, vec<3, T, P>(Pf0.x, Pf1.y, Pf0.z));
+		T n110 = dot(g110, vec<3, T, P>(Pf1.x, Pf1.y, Pf0.z));
+		T n001 = dot(g001, vec<3, T, P>(Pf0.x, Pf0.y, Pf1.z));
+		T n101 = dot(g101, vec<3, T, P>(Pf1.x, Pf0.y, Pf1.z));
+		T n011 = dot(g011, vec<3, T, P>(Pf0.x, Pf1.y, Pf1.z));
 		T n111 = dot(g111, Pf1);
 
-		tvec3<T, P> fade_xyz = detail::fade(Pf0);
-		tvec4<T, P> n_z = mix(tvec4<T, P>(n000, n100, n010, n110), tvec4<T, P>(n001, n101, n011, n111), fade_xyz.z);
-		tvec2<T, P> n_yz = mix(tvec2<T, P>(n_z.x, n_z.y), tvec2<T, P>(n_z.z, n_z.w), fade_xyz.y);
+		vec<3, T, P> fade_xyz = detail::fade(Pf0);
+		vec<4, T, P> n_z = mix(vec<4, T, P>(n000, n100, n010, n110), vec<4, T, P>(n001, n101, n011, n111), fade_xyz.z);
+		vec<2, T, P> n_yz = mix(vec<2, T, P>(n_z.x, n_z.y), vec<2, T, P>(n_z.z, n_z.w), fade_xyz.y);
 		T n_xyz = mix(n_yz.x, n_yz.y, fade_xyz.x); 
 		return T(2.2) * n_xyz;
 	}
 	/*
 	// Classic Perlin noise
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER T perlin(tvec3<T, P> const & P)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER T perlin(vec<3, T, P> const & P)
 	{
-		tvec3<T, P> Pi0 = floor(P); // Integer part for indexing
-		tvec3<T, P> Pi1 = Pi0 + T(1); // Integer part + 1
+		vec<3, T, P> Pi0 = floor(P); // Integer part for indexing
+		vec<3, T, P> Pi1 = Pi0 + T(1); // Integer part + 1
 		Pi0 = mod(Pi0, T(289));
 		Pi1 = mod(Pi1, T(289));
-		tvec3<T, P> Pf0 = fract(P); // Fractional part for interpolation
-		tvec3<T, P> Pf1 = Pf0 - T(1); // Fractional part - 1.0
-		tvec4<T, P> ix(Pi0.x, Pi1.x, Pi0.x, Pi1.x);
-		tvec4<T, P> iy(Pi0.y, Pi0.y, Pi1.y, Pi1.y);
-		tvec4<T, P> iz0(Pi0.z);
-		tvec4<T, P> iz1(Pi1.z);
+		vec<3, T, P> Pf0 = fract(P); // Fractional part for interpolation
+		vec<3, T, P> Pf1 = Pf0 - T(1); // Fractional part - 1.0
+		vec<4, T, P> ix(Pi0.x, Pi1.x, Pi0.x, Pi1.x);
+		vec<4, T, P> iy(Pi0.y, Pi0.y, Pi1.y, Pi1.y);
+		vec<4, T, P> iz0(Pi0.z);
+		vec<4, T, P> iz1(Pi1.z);
 
-		tvec4<T, P> ixy = permute(permute(ix) + iy);
-		tvec4<T, P> ixy0 = permute(ixy + iz0);
-		tvec4<T, P> ixy1 = permute(ixy + iz1);
+		vec<4, T, P> ixy = permute(permute(ix) + iy);
+		vec<4, T, P> ixy0 = permute(ixy + iz0);
+		vec<4, T, P> ixy1 = permute(ixy + iz1);
 
-		tvec4<T, P> gx0 = ixy0 / T(7);
-		tvec4<T, P> gy0 = fract(floor(gx0) / T(7)) - T(0.5);
+		vec<4, T, P> gx0 = ixy0 / T(7);
+		vec<4, T, P> gy0 = fract(floor(gx0) / T(7)) - T(0.5);
 		gx0 = fract(gx0);
-		tvec4<T, P> gz0 = tvec4<T, P>(0.5) - abs(gx0) - abs(gy0);
-		tvec4<T, P> sz0 = step(gz0, tvec4<T, P>(0.0));
+		vec<4, T, P> gz0 = vec<4, T, P>(0.5) - abs(gx0) - abs(gy0);
+		vec<4, T, P> sz0 = step(gz0, vec<4, T, P>(0.0));
 		gx0 -= sz0 * (step(0.0, gx0) - T(0.5));
 		gy0 -= sz0 * (step(0.0, gy0) - T(0.5));
 
-		tvec4<T, P> gx1 = ixy1 / T(7);
-		tvec4<T, P> gy1 = fract(floor(gx1) / T(7)) - T(0.5);
+		vec<4, T, P> gx1 = ixy1 / T(7);
+		vec<4, T, P> gy1 = fract(floor(gx1) / T(7)) - T(0.5);
 		gx1 = fract(gx1);
-		tvec4<T, P> gz1 = tvec4<T, P>(0.5) - abs(gx1) - abs(gy1);
-		tvec4<T, P> sz1 = step(gz1, tvec4<T, P>(0.0));
+		vec<4, T, P> gz1 = vec<4, T, P>(0.5) - abs(gx1) - abs(gy1);
+		vec<4, T, P> sz1 = step(gz1, vec<4, T, P>(0.0));
 		gx1 -= sz1 * (step(T(0), gx1) - T(0.5));
 		gy1 -= sz1 * (step(T(0), gy1) - T(0.5));
 
-		tvec3<T, P> g000(gx0.x, gy0.x, gz0.x);
-		tvec3<T, P> g100(gx0.y, gy0.y, gz0.y);
-		tvec3<T, P> g010(gx0.z, gy0.z, gz0.z);
-		tvec3<T, P> g110(gx0.w, gy0.w, gz0.w);
-		tvec3<T, P> g001(gx1.x, gy1.x, gz1.x);
-		tvec3<T, P> g101(gx1.y, gy1.y, gz1.y);
-		tvec3<T, P> g011(gx1.z, gy1.z, gz1.z);
-		tvec3<T, P> g111(gx1.w, gy1.w, gz1.w);
+		vec<3, T, P> g000(gx0.x, gy0.x, gz0.x);
+		vec<3, T, P> g100(gx0.y, gy0.y, gz0.y);
+		vec<3, T, P> g010(gx0.z, gy0.z, gz0.z);
+		vec<3, T, P> g110(gx0.w, gy0.w, gz0.w);
+		vec<3, T, P> g001(gx1.x, gy1.x, gz1.x);
+		vec<3, T, P> g101(gx1.y, gy1.y, gz1.y);
+		vec<3, T, P> g011(gx1.z, gy1.z, gz1.z);
+		vec<3, T, P> g111(gx1.w, gy1.w, gz1.w);
 
-		tvec4<T, P> norm0 = taylorInvSqrt(tvec4<T, P>(dot(g000, g000), dot(g010, g010), dot(g100, g100), dot(g110, g110)));
+		vec<4, T, P> norm0 = taylorInvSqrt(vec<4, T, P>(dot(g000, g000), dot(g010, g010), dot(g100, g100), dot(g110, g110)));
 		g000 *= norm0.x;
 		g010 *= norm0.y;
 		g100 *= norm0.z;
 		g110 *= norm0.w;
-		tvec4<T, P> norm1 = taylorInvSqrt(tvec4<T, P>(dot(g001, g001), dot(g011, g011), dot(g101, g101), dot(g111, g111)));
+		vec<4, T, P> norm1 = taylorInvSqrt(vec<4, T, P>(dot(g001, g001), dot(g011, g011), dot(g101, g101), dot(g111, g111)));
 		g001 *= norm1.x;
 		g011 *= norm1.y;
 		g101 *= norm1.z;
 		g111 *= norm1.w;
 
 		T n000 = dot(g000, Pf0);
-		T n100 = dot(g100, tvec3<T, P>(Pf1.x, Pf0.y, Pf0.z));
-		T n010 = dot(g010, tvec3<T, P>(Pf0.x, Pf1.y, Pf0.z));
-		T n110 = dot(g110, tvec3<T, P>(Pf1.x, Pf1.y, Pf0.z));
-		T n001 = dot(g001, tvec3<T, P>(Pf0.x, Pf0.y, Pf1.z));
-		T n101 = dot(g101, tvec3<T, P>(Pf1.x, Pf0.y, Pf1.z));
-		T n011 = dot(g011, tvec3<T, P>(Pf0.x, Pf1.y, Pf1.z));
+		T n100 = dot(g100, vec<3, T, P>(Pf1.x, Pf0.y, Pf0.z));
+		T n010 = dot(g010, vec<3, T, P>(Pf0.x, Pf1.y, Pf0.z));
+		T n110 = dot(g110, vec<3, T, P>(Pf1.x, Pf1.y, Pf0.z));
+		T n001 = dot(g001, vec<3, T, P>(Pf0.x, Pf0.y, Pf1.z));
+		T n101 = dot(g101, vec<3, T, P>(Pf1.x, Pf0.y, Pf1.z));
+		T n011 = dot(g011, vec<3, T, P>(Pf0.x, Pf1.y, Pf1.z));
 		T n111 = dot(g111, Pf1);
 
-		tvec3<T, P> fade_xyz = fade(Pf0);
-		tvec4<T, P> n_z = mix(tvec4<T, P>(n000, n100, n010, n110), tvec4<T, P>(n001, n101, n011, n111), fade_xyz.z);
-		tvec2<T, P> n_yz = mix(
-			tvec2<T, P>(n_z.x, n_z.y), 
-			tvec2<T, P>(n_z.z, n_z.w), fade_xyz.y);
+		vec<3, T, P> fade_xyz = fade(Pf0);
+		vec<4, T, P> n_z = mix(vec<4, T, P>(n000, n100, n010, n110), vec<4, T, P>(n001, n101, n011, n111), fade_xyz.z);
+		vec<2, T, P> n_yz = mix(
+			vec<2, T, P>(n_z.x, n_z.y), 
+			vec<2, T, P>(n_z.z, n_z.w), fade_xyz.y);
 		T n_xyz = mix(n_yz.x, n_yz.y, fade_xyz.x); 
 		return T(2.2) * n_xyz;
 	}
 	*/
 	// Classic Perlin noise
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER T perlin(tvec4<T, P> const & Position)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER T perlin(vec<4, T, P> const & Position)
 	{
-		tvec4<T, P> Pi0 = floor(Position);	// Integer part for indexing
-		tvec4<T, P> Pi1 = Pi0 + T(1);		// Integer part + 1
-		Pi0 = mod(Pi0, tvec4<T, P>(289));
-		Pi1 = mod(Pi1, tvec4<T, P>(289));
-		tvec4<T, P> Pf0 = fract(Position);	// Fractional part for interpolation
-		tvec4<T, P> Pf1 = Pf0 - T(1);		// Fractional part - 1.0
-		tvec4<T, P> ix(Pi0.x, Pi1.x, Pi0.x, Pi1.x);
-		tvec4<T, P> iy(Pi0.y, Pi0.y, Pi1.y, Pi1.y);
-		tvec4<T, P> iz0(Pi0.z);
-		tvec4<T, P> iz1(Pi1.z);
-		tvec4<T, P> iw0(Pi0.w);
-		tvec4<T, P> iw1(Pi1.w);
+		vec<4, T, P> Pi0 = floor(Position);	// Integer part for indexing
+		vec<4, T, P> Pi1 = Pi0 + T(1);		// Integer part + 1
+		Pi0 = mod(Pi0, vec<4, T, P>(289));
+		Pi1 = mod(Pi1, vec<4, T, P>(289));
+		vec<4, T, P> Pf0 = fract(Position);	// Fractional part for interpolation
+		vec<4, T, P> Pf1 = Pf0 - T(1);		// Fractional part - 1.0
+		vec<4, T, P> ix(Pi0.x, Pi1.x, Pi0.x, Pi1.x);
+		vec<4, T, P> iy(Pi0.y, Pi0.y, Pi1.y, Pi1.y);
+		vec<4, T, P> iz0(Pi0.z);
+		vec<4, T, P> iz1(Pi1.z);
+		vec<4, T, P> iw0(Pi0.w);
+		vec<4, T, P> iw1(Pi1.w);
 
-		tvec4<T, P> ixy = detail::permute(detail::permute(ix) + iy);
-		tvec4<T, P> ixy0 = detail::permute(ixy + iz0);
-		tvec4<T, P> ixy1 = detail::permute(ixy + iz1);
-		tvec4<T, P> ixy00 = detail::permute(ixy0 + iw0);
-		tvec4<T, P> ixy01 = detail::permute(ixy0 + iw1);
-		tvec4<T, P> ixy10 = detail::permute(ixy1 + iw0);
-		tvec4<T, P> ixy11 = detail::permute(ixy1 + iw1);
+		vec<4, T, P> ixy = detail::permute(detail::permute(ix) + iy);
+		vec<4, T, P> ixy0 = detail::permute(ixy + iz0);
+		vec<4, T, P> ixy1 = detail::permute(ixy + iz1);
+		vec<4, T, P> ixy00 = detail::permute(ixy0 + iw0);
+		vec<4, T, P> ixy01 = detail::permute(ixy0 + iw1);
+		vec<4, T, P> ixy10 = detail::permute(ixy1 + iw0);
+		vec<4, T, P> ixy11 = detail::permute(ixy1 + iw1);
 
-		tvec4<T, P> gx00 = ixy00 / T(7);
-		tvec4<T, P> gy00 = floor(gx00) / T(7);
-		tvec4<T, P> gz00 = floor(gy00) / T(6);
+		vec<4, T, P> gx00 = ixy00 / T(7);
+		vec<4, T, P> gy00 = floor(gx00) / T(7);
+		vec<4, T, P> gz00 = floor(gy00) / T(6);
 		gx00 = fract(gx00) - T(0.5);
 		gy00 = fract(gy00) - T(0.5);
 		gz00 = fract(gz00) - T(0.5);
-		tvec4<T, P> gw00 = tvec4<T, P>(0.75) - abs(gx00) - abs(gy00) - abs(gz00);
-		tvec4<T, P> sw00 = step(gw00, tvec4<T, P>(0.0));
+		vec<4, T, P> gw00 = vec<4, T, P>(0.75) - abs(gx00) - abs(gy00) - abs(gz00);
+		vec<4, T, P> sw00 = step(gw00, vec<4, T, P>(0.0));
 		gx00 -= sw00 * (step(T(0), gx00) - T(0.5));
 		gy00 -= sw00 * (step(T(0), gy00) - T(0.5));
 
-		tvec4<T, P> gx01 = ixy01 / T(7);
-		tvec4<T, P> gy01 = floor(gx01) / T(7);
-		tvec4<T, P> gz01 = floor(gy01) / T(6);
+		vec<4, T, P> gx01 = ixy01 / T(7);
+		vec<4, T, P> gy01 = floor(gx01) / T(7);
+		vec<4, T, P> gz01 = floor(gy01) / T(6);
 		gx01 = fract(gx01) - T(0.5);
 		gy01 = fract(gy01) - T(0.5);
 		gz01 = fract(gz01) - T(0.5);
-		tvec4<T, P> gw01 = tvec4<T, P>(0.75) - abs(gx01) - abs(gy01) - abs(gz01);
-		tvec4<T, P> sw01 = step(gw01, tvec4<T, P>(0.0));
+		vec<4, T, P> gw01 = vec<4, T, P>(0.75) - abs(gx01) - abs(gy01) - abs(gz01);
+		vec<4, T, P> sw01 = step(gw01, vec<4, T, P>(0.0));
 		gx01 -= sw01 * (step(T(0), gx01) - T(0.5));
 		gy01 -= sw01 * (step(T(0), gy01) - T(0.5));
 
-		tvec4<T, P> gx10 = ixy10 / T(7);
-		tvec4<T, P> gy10 = floor(gx10) / T(7);
-		tvec4<T, P> gz10 = floor(gy10) / T(6);
+		vec<4, T, P> gx10 = ixy10 / T(7);
+		vec<4, T, P> gy10 = floor(gx10) / T(7);
+		vec<4, T, P> gz10 = floor(gy10) / T(6);
 		gx10 = fract(gx10) - T(0.5);
 		gy10 = fract(gy10) - T(0.5);
 		gz10 = fract(gz10) - T(0.5);
-		tvec4<T, P> gw10 = tvec4<T, P>(0.75) - abs(gx10) - abs(gy10) - abs(gz10);
-		tvec4<T, P> sw10 = step(gw10, tvec4<T, P>(0));
+		vec<4, T, P> gw10 = vec<4, T, P>(0.75) - abs(gx10) - abs(gy10) - abs(gz10);
+		vec<4, T, P> sw10 = step(gw10, vec<4, T, P>(0));
 		gx10 -= sw10 * (step(T(0), gx10) - T(0.5));
 		gy10 -= sw10 * (step(T(0), gy10) - T(0.5));
 
-		tvec4<T, P> gx11 = ixy11 / T(7);
-		tvec4<T, P> gy11 = floor(gx11) / T(7);
-		tvec4<T, P> gz11 = floor(gy11) / T(6);
+		vec<4, T, P> gx11 = ixy11 / T(7);
+		vec<4, T, P> gy11 = floor(gx11) / T(7);
+		vec<4, T, P> gz11 = floor(gy11) / T(6);
 		gx11 = fract(gx11) - T(0.5);
 		gy11 = fract(gy11) - T(0.5);
 		gz11 = fract(gz11) - T(0.5);
-		tvec4<T, P> gw11 = tvec4<T, P>(0.75) - abs(gx11) - abs(gy11) - abs(gz11);
-		tvec4<T, P> sw11 = step(gw11, tvec4<T, P>(0.0));
+		vec<4, T, P> gw11 = vec<4, T, P>(0.75) - abs(gx11) - abs(gy11) - abs(gz11);
+		vec<4, T, P> sw11 = step(gw11, vec<4, T, P>(0.0));
 		gx11 -= sw11 * (step(T(0), gx11) - T(0.5));
 		gy11 -= sw11 * (step(T(0), gy11) - T(0.5));
 
-		tvec4<T, P> g0000(gx00.x, gy00.x, gz00.x, gw00.x);
-		tvec4<T, P> g1000(gx00.y, gy00.y, gz00.y, gw00.y);
-		tvec4<T, P> g0100(gx00.z, gy00.z, gz00.z, gw00.z);
-		tvec4<T, P> g1100(gx00.w, gy00.w, gz00.w, gw00.w);
-		tvec4<T, P> g0010(gx10.x, gy10.x, gz10.x, gw10.x);
-		tvec4<T, P> g1010(gx10.y, gy10.y, gz10.y, gw10.y);
-		tvec4<T, P> g0110(gx10.z, gy10.z, gz10.z, gw10.z);
-		tvec4<T, P> g1110(gx10.w, gy10.w, gz10.w, gw10.w);
-		tvec4<T, P> g0001(gx01.x, gy01.x, gz01.x, gw01.x);
-		tvec4<T, P> g1001(gx01.y, gy01.y, gz01.y, gw01.y);
-		tvec4<T, P> g0101(gx01.z, gy01.z, gz01.z, gw01.z);
-		tvec4<T, P> g1101(gx01.w, gy01.w, gz01.w, gw01.w);
-		tvec4<T, P> g0011(gx11.x, gy11.x, gz11.x, gw11.x);
-		tvec4<T, P> g1011(gx11.y, gy11.y, gz11.y, gw11.y);
-		tvec4<T, P> g0111(gx11.z, gy11.z, gz11.z, gw11.z);
-		tvec4<T, P> g1111(gx11.w, gy11.w, gz11.w, gw11.w);
+		vec<4, T, P> g0000(gx00.x, gy00.x, gz00.x, gw00.x);
+		vec<4, T, P> g1000(gx00.y, gy00.y, gz00.y, gw00.y);
+		vec<4, T, P> g0100(gx00.z, gy00.z, gz00.z, gw00.z);
+		vec<4, T, P> g1100(gx00.w, gy00.w, gz00.w, gw00.w);
+		vec<4, T, P> g0010(gx10.x, gy10.x, gz10.x, gw10.x);
+		vec<4, T, P> g1010(gx10.y, gy10.y, gz10.y, gw10.y);
+		vec<4, T, P> g0110(gx10.z, gy10.z, gz10.z, gw10.z);
+		vec<4, T, P> g1110(gx10.w, gy10.w, gz10.w, gw10.w);
+		vec<4, T, P> g0001(gx01.x, gy01.x, gz01.x, gw01.x);
+		vec<4, T, P> g1001(gx01.y, gy01.y, gz01.y, gw01.y);
+		vec<4, T, P> g0101(gx01.z, gy01.z, gz01.z, gw01.z);
+		vec<4, T, P> g1101(gx01.w, gy01.w, gz01.w, gw01.w);
+		vec<4, T, P> g0011(gx11.x, gy11.x, gz11.x, gw11.x);
+		vec<4, T, P> g1011(gx11.y, gy11.y, gz11.y, gw11.y);
+		vec<4, T, P> g0111(gx11.z, gy11.z, gz11.z, gw11.z);
+		vec<4, T, P> g1111(gx11.w, gy11.w, gz11.w, gw11.w);
 
-		tvec4<T, P> norm00 = detail::taylorInvSqrt(tvec4<T, P>(dot(g0000, g0000), dot(g0100, g0100), dot(g1000, g1000), dot(g1100, g1100)));
+		vec<4, T, P> norm00 = detail::taylorInvSqrt(vec<4, T, P>(dot(g0000, g0000), dot(g0100, g0100), dot(g1000, g1000), dot(g1100, g1100)));
 		g0000 *= norm00.x;
 		g0100 *= norm00.y;
 		g1000 *= norm00.z;
 		g1100 *= norm00.w;
 
-		tvec4<T, P> norm01 = detail::taylorInvSqrt(tvec4<T, P>(dot(g0001, g0001), dot(g0101, g0101), dot(g1001, g1001), dot(g1101, g1101)));
+		vec<4, T, P> norm01 = detail::taylorInvSqrt(vec<4, T, P>(dot(g0001, g0001), dot(g0101, g0101), dot(g1001, g1001), dot(g1101, g1101)));
 		g0001 *= norm01.x;
 		g0101 *= norm01.y;
 		g1001 *= norm01.z;
 		g1101 *= norm01.w;
 
-		tvec4<T, P> norm10 = detail::taylorInvSqrt(tvec4<T, P>(dot(g0010, g0010), dot(g0110, g0110), dot(g1010, g1010), dot(g1110, g1110)));
+		vec<4, T, P> norm10 = detail::taylorInvSqrt(vec<4, T, P>(dot(g0010, g0010), dot(g0110, g0110), dot(g1010, g1010), dot(g1110, g1110)));
 		g0010 *= norm10.x;
 		g0110 *= norm10.y;
 		g1010 *= norm10.z;
 		g1110 *= norm10.w;
 
-		tvec4<T, P> norm11 = detail::taylorInvSqrt(tvec4<T, P>(dot(g0011, g0011), dot(g0111, g0111), dot(g1011, g1011), dot(g1111, g1111)));
+		vec<4, T, P> norm11 = detail::taylorInvSqrt(vec<4, T, P>(dot(g0011, g0011), dot(g0111, g0111), dot(g1011, g1011), dot(g1111, g1111)));
 		g0011 *= norm11.x;
 		g0111 *= norm11.y;
 		g1011 *= norm11.z;
 		g1111 *= norm11.w;
 
 		T n0000 = dot(g0000, Pf0);
-		T n1000 = dot(g1000, tvec4<T, P>(Pf1.x, Pf0.y, Pf0.z, Pf0.w));
-		T n0100 = dot(g0100, tvec4<T, P>(Pf0.x, Pf1.y, Pf0.z, Pf0.w));
-		T n1100 = dot(g1100, tvec4<T, P>(Pf1.x, Pf1.y, Pf0.z, Pf0.w));
-		T n0010 = dot(g0010, tvec4<T, P>(Pf0.x, Pf0.y, Pf1.z, Pf0.w));
-		T n1010 = dot(g1010, tvec4<T, P>(Pf1.x, Pf0.y, Pf1.z, Pf0.w));
-		T n0110 = dot(g0110, tvec4<T, P>(Pf0.x, Pf1.y, Pf1.z, Pf0.w));
-		T n1110 = dot(g1110, tvec4<T, P>(Pf1.x, Pf1.y, Pf1.z, Pf0.w));
-		T n0001 = dot(g0001, tvec4<T, P>(Pf0.x, Pf0.y, Pf0.z, Pf1.w));
-		T n1001 = dot(g1001, tvec4<T, P>(Pf1.x, Pf0.y, Pf0.z, Pf1.w));
-		T n0101 = dot(g0101, tvec4<T, P>(Pf0.x, Pf1.y, Pf0.z, Pf1.w));
-		T n1101 = dot(g1101, tvec4<T, P>(Pf1.x, Pf1.y, Pf0.z, Pf1.w));
-		T n0011 = dot(g0011, tvec4<T, P>(Pf0.x, Pf0.y, Pf1.z, Pf1.w));
-		T n1011 = dot(g1011, tvec4<T, P>(Pf1.x, Pf0.y, Pf1.z, Pf1.w));
-		T n0111 = dot(g0111, tvec4<T, P>(Pf0.x, Pf1.y, Pf1.z, Pf1.w));
+		T n1000 = dot(g1000, vec<4, T, P>(Pf1.x, Pf0.y, Pf0.z, Pf0.w));
+		T n0100 = dot(g0100, vec<4, T, P>(Pf0.x, Pf1.y, Pf0.z, Pf0.w));
+		T n1100 = dot(g1100, vec<4, T, P>(Pf1.x, Pf1.y, Pf0.z, Pf0.w));
+		T n0010 = dot(g0010, vec<4, T, P>(Pf0.x, Pf0.y, Pf1.z, Pf0.w));
+		T n1010 = dot(g1010, vec<4, T, P>(Pf1.x, Pf0.y, Pf1.z, Pf0.w));
+		T n0110 = dot(g0110, vec<4, T, P>(Pf0.x, Pf1.y, Pf1.z, Pf0.w));
+		T n1110 = dot(g1110, vec<4, T, P>(Pf1.x, Pf1.y, Pf1.z, Pf0.w));
+		T n0001 = dot(g0001, vec<4, T, P>(Pf0.x, Pf0.y, Pf0.z, Pf1.w));
+		T n1001 = dot(g1001, vec<4, T, P>(Pf1.x, Pf0.y, Pf0.z, Pf1.w));
+		T n0101 = dot(g0101, vec<4, T, P>(Pf0.x, Pf1.y, Pf0.z, Pf1.w));
+		T n1101 = dot(g1101, vec<4, T, P>(Pf1.x, Pf1.y, Pf0.z, Pf1.w));
+		T n0011 = dot(g0011, vec<4, T, P>(Pf0.x, Pf0.y, Pf1.z, Pf1.w));
+		T n1011 = dot(g1011, vec<4, T, P>(Pf1.x, Pf0.y, Pf1.z, Pf1.w));
+		T n0111 = dot(g0111, vec<4, T, P>(Pf0.x, Pf1.y, Pf1.z, Pf1.w));
 		T n1111 = dot(g1111, Pf1);
 
-		tvec4<T, P> fade_xyzw = detail::fade(Pf0);
-		tvec4<T, P> n_0w = mix(tvec4<T, P>(n0000, n1000, n0100, n1100), tvec4<T, P>(n0001, n1001, n0101, n1101), fade_xyzw.w);
-		tvec4<T, P> n_1w = mix(tvec4<T, P>(n0010, n1010, n0110, n1110), tvec4<T, P>(n0011, n1011, n0111, n1111), fade_xyzw.w);
-		tvec4<T, P> n_zw = mix(n_0w, n_1w, fade_xyzw.z);
-		tvec2<T, P> n_yzw = mix(tvec2<T, P>(n_zw.x, n_zw.y), tvec2<T, P>(n_zw.z, n_zw.w), fade_xyzw.y);
+		vec<4, T, P> fade_xyzw = detail::fade(Pf0);
+		vec<4, T, P> n_0w = mix(vec<4, T, P>(n0000, n1000, n0100, n1100), vec<4, T, P>(n0001, n1001, n0101, n1101), fade_xyzw.w);
+		vec<4, T, P> n_1w = mix(vec<4, T, P>(n0010, n1010, n0110, n1110), vec<4, T, P>(n0011, n1011, n0111, n1111), fade_xyzw.w);
+		vec<4, T, P> n_zw = mix(n_0w, n_1w, fade_xyzw.z);
+		vec<2, T, P> n_yzw = mix(vec<2, T, P>(n_zw.x, n_zw.y), vec<2, T, P>(n_zw.z, n_zw.w), fade_xyzw.y);
 		T n_xyzw = mix(n_yzw.x, n_yzw.y, fade_xyzw.x);
 		return T(2.2) * n_xyzw;
 	}
 
 	// Classic Perlin noise, periodic variant
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER T perlin(tvec2<T, P> const & Position, tvec2<T, P> const & rep)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER T perlin(vec<2, T, P> const & Position, vec<2, T, P> const & rep)
 	{
-		tvec4<T, P> Pi = floor(tvec4<T, P>(Position.x, Position.y, Position.x, Position.y)) + tvec4<T, P>(0.0, 0.0, 1.0, 1.0);
-		tvec4<T, P> Pf = fract(tvec4<T, P>(Position.x, Position.y, Position.x, Position.y)) - tvec4<T, P>(0.0, 0.0, 1.0, 1.0);
-		Pi = mod(Pi, tvec4<T, P>(rep.x, rep.y, rep.x, rep.y)); // To create noise with explicit period
-		Pi = mod(Pi, tvec4<T, P>(289)); // To avoid truncation effects in permutation
-		tvec4<T, P> ix(Pi.x, Pi.z, Pi.x, Pi.z);
-		tvec4<T, P> iy(Pi.y, Pi.y, Pi.w, Pi.w);
-		tvec4<T, P> fx(Pf.x, Pf.z, Pf.x, Pf.z);
-		tvec4<T, P> fy(Pf.y, Pf.y, Pf.w, Pf.w);
+		vec<4, T, P> Pi = floor(vec<4, T, P>(Position.x, Position.y, Position.x, Position.y)) + vec<4, T, P>(0.0, 0.0, 1.0, 1.0);
+		vec<4, T, P> Pf = fract(vec<4, T, P>(Position.x, Position.y, Position.x, Position.y)) - vec<4, T, P>(0.0, 0.0, 1.0, 1.0);
+		Pi = mod(Pi, vec<4, T, P>(rep.x, rep.y, rep.x, rep.y)); // To create noise with explicit period
+		Pi = mod(Pi, vec<4, T, P>(289)); // To avoid truncation effects in permutation
+		vec<4, T, P> ix(Pi.x, Pi.z, Pi.x, Pi.z);
+		vec<4, T, P> iy(Pi.y, Pi.y, Pi.w, Pi.w);
+		vec<4, T, P> fx(Pf.x, Pf.z, Pf.x, Pf.z);
+		vec<4, T, P> fy(Pf.y, Pf.y, Pf.w, Pf.w);
 
-		tvec4<T, P> i = detail::permute(detail::permute(ix) + iy);
+		vec<4, T, P> i = detail::permute(detail::permute(ix) + iy);
 
-		tvec4<T, P> gx = static_cast<T>(2) * fract(i / T(41)) - T(1);
-		tvec4<T, P> gy = abs(gx) - T(0.5);
-		tvec4<T, P> tx = floor(gx + T(0.5));
+		vec<4, T, P> gx = static_cast<T>(2) * fract(i / T(41)) - T(1);
+		vec<4, T, P> gy = abs(gx) - T(0.5);
+		vec<4, T, P> tx = floor(gx + T(0.5));
 		gx = gx - tx;
 
-		tvec2<T, P> g00(gx.x, gy.x);
-		tvec2<T, P> g10(gx.y, gy.y);
-		tvec2<T, P> g01(gx.z, gy.z);
-		tvec2<T, P> g11(gx.w, gy.w);
+		vec<2, T, P> g00(gx.x, gy.x);
+		vec<2, T, P> g10(gx.y, gy.y);
+		vec<2, T, P> g01(gx.z, gy.z);
+		vec<2, T, P> g11(gx.w, gy.w);
 
-		tvec4<T, P> norm = detail::taylorInvSqrt(tvec4<T, P>(dot(g00, g00), dot(g01, g01), dot(g10, g10), dot(g11, g11)));
+		vec<4, T, P> norm = detail::taylorInvSqrt(vec<4, T, P>(dot(g00, g00), dot(g01, g01), dot(g10, g10), dot(g11, g11)));
 		g00 *= norm.x;
 		g01 *= norm.y;
 		g10 *= norm.z;
 		g11 *= norm.w;
 
-		T n00 = dot(g00, tvec2<T, P>(fx.x, fy.x));
-		T n10 = dot(g10, tvec2<T, P>(fx.y, fy.y));
-		T n01 = dot(g01, tvec2<T, P>(fx.z, fy.z));
-		T n11 = dot(g11, tvec2<T, P>(fx.w, fy.w));
+		T n00 = dot(g00, vec<2, T, P>(fx.x, fy.x));
+		T n10 = dot(g10, vec<2, T, P>(fx.y, fy.y));
+		T n01 = dot(g01, vec<2, T, P>(fx.z, fy.z));
+		T n11 = dot(g11, vec<2, T, P>(fx.w, fy.w));
 
-		tvec2<T, P> fade_xy = detail::fade(tvec2<T, P>(Pf.x, Pf.y));
-		tvec2<T, P> n_x = mix(tvec2<T, P>(n00, n01), tvec2<T, P>(n10, n11), fade_xy.x);
+		vec<2, T, P> fade_xy = detail::fade(vec<2, T, P>(Pf.x, Pf.y));
+		vec<2, T, P> n_x = mix(vec<2, T, P>(n00, n01), vec<2, T, P>(n10, n11), fade_xy.x);
 		T n_xy = mix(n_x.x, n_x.y, fade_xy.y);
 		return T(2.3) * n_xy;
 	}
 
 	// Classic Perlin noise, periodic variant
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER T perlin(tvec3<T, P> const & Position, tvec3<T, P> const & rep)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER T perlin(vec<3, T, P> const & Position, vec<3, T, P> const & rep)
 	{
-		tvec3<T, P> Pi0 = mod(floor(Position), rep); // Integer part, modulo period
-		tvec3<T, P> Pi1 = mod(Pi0 + tvec3<T, P>(T(1)), rep); // Integer part + 1, mod period
-		Pi0 = mod(Pi0, tvec3<T, P>(289));
-		Pi1 = mod(Pi1, tvec3<T, P>(289));
-		tvec3<T, P> Pf0 = fract(Position); // Fractional part for interpolation
-		tvec3<T, P> Pf1 = Pf0 - tvec3<T, P>(T(1)); // Fractional part - 1.0
-		tvec4<T, P> ix = tvec4<T, P>(Pi0.x, Pi1.x, Pi0.x, Pi1.x);
-		tvec4<T, P> iy = tvec4<T, P>(Pi0.y, Pi0.y, Pi1.y, Pi1.y);
-		tvec4<T, P> iz0(Pi0.z);
-		tvec4<T, P> iz1(Pi1.z);
+		vec<3, T, P> Pi0 = mod(floor(Position), rep); // Integer part, modulo period
+		vec<3, T, P> Pi1 = mod(Pi0 + vec<3, T, P>(T(1)), rep); // Integer part + 1, mod period
+		Pi0 = mod(Pi0, vec<3, T, P>(289));
+		Pi1 = mod(Pi1, vec<3, T, P>(289));
+		vec<3, T, P> Pf0 = fract(Position); // Fractional part for interpolation
+		vec<3, T, P> Pf1 = Pf0 - vec<3, T, P>(T(1)); // Fractional part - 1.0
+		vec<4, T, P> ix = vec<4, T, P>(Pi0.x, Pi1.x, Pi0.x, Pi1.x);
+		vec<4, T, P> iy = vec<4, T, P>(Pi0.y, Pi0.y, Pi1.y, Pi1.y);
+		vec<4, T, P> iz0(Pi0.z);
+		vec<4, T, P> iz1(Pi1.z);
 
-		tvec4<T, P> ixy = detail::permute(detail::permute(ix) + iy);
-		tvec4<T, P> ixy0 = detail::permute(ixy + iz0);
-		tvec4<T, P> ixy1 = detail::permute(ixy + iz1);
+		vec<4, T, P> ixy = detail::permute(detail::permute(ix) + iy);
+		vec<4, T, P> ixy0 = detail::permute(ixy + iz0);
+		vec<4, T, P> ixy1 = detail::permute(ixy + iz1);
 
-		tvec4<T, P> gx0 = ixy0 / T(7);
-		tvec4<T, P> gy0 = fract(floor(gx0) / T(7)) - T(0.5);
+		vec<4, T, P> gx0 = ixy0 / T(7);
+		vec<4, T, P> gy0 = fract(floor(gx0) / T(7)) - T(0.5);
 		gx0 = fract(gx0);
-		tvec4<T, P> gz0 = tvec4<T, P>(0.5) - abs(gx0) - abs(gy0);
-		tvec4<T, P> sz0 = step(gz0, tvec4<T, P>(0));
+		vec<4, T, P> gz0 = vec<4, T, P>(0.5) - abs(gx0) - abs(gy0);
+		vec<4, T, P> sz0 = step(gz0, vec<4, T, P>(0));
 		gx0 -= sz0 * (step(T(0), gx0) - T(0.5));
 		gy0 -= sz0 * (step(T(0), gy0) - T(0.5));
 
-		tvec4<T, P> gx1 = ixy1 / T(7);
-		tvec4<T, P> gy1 = fract(floor(gx1) / T(7)) - T(0.5);
+		vec<4, T, P> gx1 = ixy1 / T(7);
+		vec<4, T, P> gy1 = fract(floor(gx1) / T(7)) - T(0.5);
 		gx1 = fract(gx1);
-		tvec4<T, P> gz1 = tvec4<T, P>(0.5) - abs(gx1) - abs(gy1);
-		tvec4<T, P> sz1 = step(gz1, tvec4<T, P>(T(0)));
+		vec<4, T, P> gz1 = vec<4, T, P>(0.5) - abs(gx1) - abs(gy1);
+		vec<4, T, P> sz1 = step(gz1, vec<4, T, P>(T(0)));
 		gx1 -= sz1 * (step(T(0), gx1) - T(0.5));
 		gy1 -= sz1 * (step(T(0), gy1) - T(0.5));
 
-		tvec3<T, P> g000 = tvec3<T, P>(gx0.x, gy0.x, gz0.x);
-		tvec3<T, P> g100 = tvec3<T, P>(gx0.y, gy0.y, gz0.y);
-		tvec3<T, P> g010 = tvec3<T, P>(gx0.z, gy0.z, gz0.z);
-		tvec3<T, P> g110 = tvec3<T, P>(gx0.w, gy0.w, gz0.w);
-		tvec3<T, P> g001 = tvec3<T, P>(gx1.x, gy1.x, gz1.x);
-		tvec3<T, P> g101 = tvec3<T, P>(gx1.y, gy1.y, gz1.y);
-		tvec3<T, P> g011 = tvec3<T, P>(gx1.z, gy1.z, gz1.z);
-		tvec3<T, P> g111 = tvec3<T, P>(gx1.w, gy1.w, gz1.w);
+		vec<3, T, P> g000 = vec<3, T, P>(gx0.x, gy0.x, gz0.x);
+		vec<3, T, P> g100 = vec<3, T, P>(gx0.y, gy0.y, gz0.y);
+		vec<3, T, P> g010 = vec<3, T, P>(gx0.z, gy0.z, gz0.z);
+		vec<3, T, P> g110 = vec<3, T, P>(gx0.w, gy0.w, gz0.w);
+		vec<3, T, P> g001 = vec<3, T, P>(gx1.x, gy1.x, gz1.x);
+		vec<3, T, P> g101 = vec<3, T, P>(gx1.y, gy1.y, gz1.y);
+		vec<3, T, P> g011 = vec<3, T, P>(gx1.z, gy1.z, gz1.z);
+		vec<3, T, P> g111 = vec<3, T, P>(gx1.w, gy1.w, gz1.w);
 
-		tvec4<T, P> norm0 = detail::taylorInvSqrt(tvec4<T, P>(dot(g000, g000), dot(g010, g010), dot(g100, g100), dot(g110, g110)));
+		vec<4, T, P> norm0 = detail::taylorInvSqrt(vec<4, T, P>(dot(g000, g000), dot(g010, g010), dot(g100, g100), dot(g110, g110)));
 		g000 *= norm0.x;
 		g010 *= norm0.y;
 		g100 *= norm0.z;
 		g110 *= norm0.w;
-		tvec4<T, P> norm1 = detail::taylorInvSqrt(tvec4<T, P>(dot(g001, g001), dot(g011, g011), dot(g101, g101), dot(g111, g111)));
+		vec<4, T, P> norm1 = detail::taylorInvSqrt(vec<4, T, P>(dot(g001, g001), dot(g011, g011), dot(g101, g101), dot(g111, g111)));
 		g001 *= norm1.x;
 		g011 *= norm1.y;
 		g101 *= norm1.z;
 		g111 *= norm1.w;
 
 		T n000 = dot(g000, Pf0);
-		T n100 = dot(g100, tvec3<T, P>(Pf1.x, Pf0.y, Pf0.z));
-		T n010 = dot(g010, tvec3<T, P>(Pf0.x, Pf1.y, Pf0.z));
-		T n110 = dot(g110, tvec3<T, P>(Pf1.x, Pf1.y, Pf0.z));
-		T n001 = dot(g001, tvec3<T, P>(Pf0.x, Pf0.y, Pf1.z));
-		T n101 = dot(g101, tvec3<T, P>(Pf1.x, Pf0.y, Pf1.z));
-		T n011 = dot(g011, tvec3<T, P>(Pf0.x, Pf1.y, Pf1.z));
+		T n100 = dot(g100, vec<3, T, P>(Pf1.x, Pf0.y, Pf0.z));
+		T n010 = dot(g010, vec<3, T, P>(Pf0.x, Pf1.y, Pf0.z));
+		T n110 = dot(g110, vec<3, T, P>(Pf1.x, Pf1.y, Pf0.z));
+		T n001 = dot(g001, vec<3, T, P>(Pf0.x, Pf0.y, Pf1.z));
+		T n101 = dot(g101, vec<3, T, P>(Pf1.x, Pf0.y, Pf1.z));
+		T n011 = dot(g011, vec<3, T, P>(Pf0.x, Pf1.y, Pf1.z));
 		T n111 = dot(g111, Pf1);
 
-		tvec3<T, P> fade_xyz = detail::fade(Pf0);
-		tvec4<T, P> n_z = mix(tvec4<T, P>(n000, n100, n010, n110), tvec4<T, P>(n001, n101, n011, n111), fade_xyz.z);
-		tvec2<T, P> n_yz = mix(tvec2<T, P>(n_z.x, n_z.y), tvec2<T, P>(n_z.z, n_z.w), fade_xyz.y);
+		vec<3, T, P> fade_xyz = detail::fade(Pf0);
+		vec<4, T, P> n_z = mix(vec<4, T, P>(n000, n100, n010, n110), vec<4, T, P>(n001, n101, n011, n111), fade_xyz.z);
+		vec<2, T, P> n_yz = mix(vec<2, T, P>(n_z.x, n_z.y), vec<2, T, P>(n_z.z, n_z.w), fade_xyz.y);
 		T n_xyz = mix(n_yz.x, n_yz.y, fade_xyz.x);
 		return T(2.2) * n_xyz;
 	}
 
 	// Classic Perlin noise, periodic version
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER T perlin(tvec4<T, P> const & Position, tvec4<T, P> const & rep)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER T perlin(vec<4, T, P> const & Position, vec<4, T, P> const & rep)
 	{
-		tvec4<T, P> Pi0 = mod(floor(Position), rep); // Integer part modulo rep
-		tvec4<T, P> Pi1 = mod(Pi0 + T(1), rep); // Integer part + 1 mod rep
-		tvec4<T, P> Pf0 = fract(Position); // Fractional part for interpolation
-		tvec4<T, P> Pf1 = Pf0 - T(1); // Fractional part - 1.0
-		tvec4<T, P> ix = tvec4<T, P>(Pi0.x, Pi1.x, Pi0.x, Pi1.x);
-		tvec4<T, P> iy = tvec4<T, P>(Pi0.y, Pi0.y, Pi1.y, Pi1.y);
-		tvec4<T, P> iz0(Pi0.z);
-		tvec4<T, P> iz1(Pi1.z);
-		tvec4<T, P> iw0(Pi0.w);
-		tvec4<T, P> iw1(Pi1.w);
+		vec<4, T, P> Pi0 = mod(floor(Position), rep); // Integer part modulo rep
+		vec<4, T, P> Pi1 = mod(Pi0 + T(1), rep); // Integer part + 1 mod rep
+		vec<4, T, P> Pf0 = fract(Position); // Fractional part for interpolation
+		vec<4, T, P> Pf1 = Pf0 - T(1); // Fractional part - 1.0
+		vec<4, T, P> ix = vec<4, T, P>(Pi0.x, Pi1.x, Pi0.x, Pi1.x);
+		vec<4, T, P> iy = vec<4, T, P>(Pi0.y, Pi0.y, Pi1.y, Pi1.y);
+		vec<4, T, P> iz0(Pi0.z);
+		vec<4, T, P> iz1(Pi1.z);
+		vec<4, T, P> iw0(Pi0.w);
+		vec<4, T, P> iw1(Pi1.w);
 
-		tvec4<T, P> ixy = detail::permute(detail::permute(ix) + iy);
-		tvec4<T, P> ixy0 = detail::permute(ixy + iz0);
-		tvec4<T, P> ixy1 = detail::permute(ixy + iz1);
-		tvec4<T, P> ixy00 = detail::permute(ixy0 + iw0);
-		tvec4<T, P> ixy01 = detail::permute(ixy0 + iw1);
-		tvec4<T, P> ixy10 = detail::permute(ixy1 + iw0);
-		tvec4<T, P> ixy11 = detail::permute(ixy1 + iw1);
+		vec<4, T, P> ixy = detail::permute(detail::permute(ix) + iy);
+		vec<4, T, P> ixy0 = detail::permute(ixy + iz0);
+		vec<4, T, P> ixy1 = detail::permute(ixy + iz1);
+		vec<4, T, P> ixy00 = detail::permute(ixy0 + iw0);
+		vec<4, T, P> ixy01 = detail::permute(ixy0 + iw1);
+		vec<4, T, P> ixy10 = detail::permute(ixy1 + iw0);
+		vec<4, T, P> ixy11 = detail::permute(ixy1 + iw1);
 
-		tvec4<T, P> gx00 = ixy00 / T(7);
-		tvec4<T, P> gy00 = floor(gx00) / T(7);
-		tvec4<T, P> gz00 = floor(gy00) / T(6);
+		vec<4, T, P> gx00 = ixy00 / T(7);
+		vec<4, T, P> gy00 = floor(gx00) / T(7);
+		vec<4, T, P> gz00 = floor(gy00) / T(6);
 		gx00 = fract(gx00) - T(0.5);
 		gy00 = fract(gy00) - T(0.5);
 		gz00 = fract(gz00) - T(0.5);
-		tvec4<T, P> gw00 = tvec4<T, P>(0.75) - abs(gx00) - abs(gy00) - abs(gz00);
-		tvec4<T, P> sw00 = step(gw00, tvec4<T, P>(0));
+		vec<4, T, P> gw00 = vec<4, T, P>(0.75) - abs(gx00) - abs(gy00) - abs(gz00);
+		vec<4, T, P> sw00 = step(gw00, vec<4, T, P>(0));
 		gx00 -= sw00 * (step(T(0), gx00) - T(0.5));
 		gy00 -= sw00 * (step(T(0), gy00) - T(0.5));
 
-		tvec4<T, P> gx01 = ixy01 / T(7);
-		tvec4<T, P> gy01 = floor(gx01) / T(7);
-		tvec4<T, P> gz01 = floor(gy01) / T(6);
+		vec<4, T, P> gx01 = ixy01 / T(7);
+		vec<4, T, P> gy01 = floor(gx01) / T(7);
+		vec<4, T, P> gz01 = floor(gy01) / T(6);
 		gx01 = fract(gx01) - T(0.5);
 		gy01 = fract(gy01) - T(0.5);
 		gz01 = fract(gz01) - T(0.5);
-		tvec4<T, P> gw01 = tvec4<T, P>(0.75) - abs(gx01) - abs(gy01) - abs(gz01);
-		tvec4<T, P> sw01 = step(gw01, tvec4<T, P>(0.0));
+		vec<4, T, P> gw01 = vec<4, T, P>(0.75) - abs(gx01) - abs(gy01) - abs(gz01);
+		vec<4, T, P> sw01 = step(gw01, vec<4, T, P>(0.0));
 		gx01 -= sw01 * (step(T(0), gx01) - T(0.5));
 		gy01 -= sw01 * (step(T(0), gy01) - T(0.5));
 
-		tvec4<T, P> gx10 = ixy10 / T(7);
-		tvec4<T, P> gy10 = floor(gx10) / T(7);
-		tvec4<T, P> gz10 = floor(gy10) / T(6);
+		vec<4, T, P> gx10 = ixy10 / T(7);
+		vec<4, T, P> gy10 = floor(gx10) / T(7);
+		vec<4, T, P> gz10 = floor(gy10) / T(6);
 		gx10 = fract(gx10) - T(0.5);
 		gy10 = fract(gy10) - T(0.5);
 		gz10 = fract(gz10) - T(0.5);
-		tvec4<T, P> gw10 = tvec4<T, P>(0.75) - abs(gx10) - abs(gy10) - abs(gz10);
-		tvec4<T, P> sw10 = step(gw10, tvec4<T, P>(0.0));
+		vec<4, T, P> gw10 = vec<4, T, P>(0.75) - abs(gx10) - abs(gy10) - abs(gz10);
+		vec<4, T, P> sw10 = step(gw10, vec<4, T, P>(0.0));
 		gx10 -= sw10 * (step(T(0), gx10) - T(0.5));
 		gy10 -= sw10 * (step(T(0), gy10) - T(0.5));
 
-		tvec4<T, P> gx11 = ixy11 / T(7);
-		tvec4<T, P> gy11 = floor(gx11) / T(7);
-		tvec4<T, P> gz11 = floor(gy11) / T(6);
+		vec<4, T, P> gx11 = ixy11 / T(7);
+		vec<4, T, P> gy11 = floor(gx11) / T(7);
+		vec<4, T, P> gz11 = floor(gy11) / T(6);
 		gx11 = fract(gx11) - T(0.5);
 		gy11 = fract(gy11) - T(0.5);
 		gz11 = fract(gz11) - T(0.5);
-		tvec4<T, P> gw11 = tvec4<T, P>(0.75) - abs(gx11) - abs(gy11) - abs(gz11);
-		tvec4<T, P> sw11 = step(gw11, tvec4<T, P>(T(0)));
+		vec<4, T, P> gw11 = vec<4, T, P>(0.75) - abs(gx11) - abs(gy11) - abs(gz11);
+		vec<4, T, P> sw11 = step(gw11, vec<4, T, P>(T(0)));
 		gx11 -= sw11 * (step(T(0), gx11) - T(0.5));
 		gy11 -= sw11 * (step(T(0), gy11) - T(0.5));
 
-		tvec4<T, P> g0000(gx00.x, gy00.x, gz00.x, gw00.x);
-		tvec4<T, P> g1000(gx00.y, gy00.y, gz00.y, gw00.y);
-		tvec4<T, P> g0100(gx00.z, gy00.z, gz00.z, gw00.z);
-		tvec4<T, P> g1100(gx00.w, gy00.w, gz00.w, gw00.w);
-		tvec4<T, P> g0010(gx10.x, gy10.x, gz10.x, gw10.x);
-		tvec4<T, P> g1010(gx10.y, gy10.y, gz10.y, gw10.y);
-		tvec4<T, P> g0110(gx10.z, gy10.z, gz10.z, gw10.z);
-		tvec4<T, P> g1110(gx10.w, gy10.w, gz10.w, gw10.w);
-		tvec4<T, P> g0001(gx01.x, gy01.x, gz01.x, gw01.x);
-		tvec4<T, P> g1001(gx01.y, gy01.y, gz01.y, gw01.y);
-		tvec4<T, P> g0101(gx01.z, gy01.z, gz01.z, gw01.z);
-		tvec4<T, P> g1101(gx01.w, gy01.w, gz01.w, gw01.w);
-		tvec4<T, P> g0011(gx11.x, gy11.x, gz11.x, gw11.x);
-		tvec4<T, P> g1011(gx11.y, gy11.y, gz11.y, gw11.y);
-		tvec4<T, P> g0111(gx11.z, gy11.z, gz11.z, gw11.z);
-		tvec4<T, P> g1111(gx11.w, gy11.w, gz11.w, gw11.w);
+		vec<4, T, P> g0000(gx00.x, gy00.x, gz00.x, gw00.x);
+		vec<4, T, P> g1000(gx00.y, gy00.y, gz00.y, gw00.y);
+		vec<4, T, P> g0100(gx00.z, gy00.z, gz00.z, gw00.z);
+		vec<4, T, P> g1100(gx00.w, gy00.w, gz00.w, gw00.w);
+		vec<4, T, P> g0010(gx10.x, gy10.x, gz10.x, gw10.x);
+		vec<4, T, P> g1010(gx10.y, gy10.y, gz10.y, gw10.y);
+		vec<4, T, P> g0110(gx10.z, gy10.z, gz10.z, gw10.z);
+		vec<4, T, P> g1110(gx10.w, gy10.w, gz10.w, gw10.w);
+		vec<4, T, P> g0001(gx01.x, gy01.x, gz01.x, gw01.x);
+		vec<4, T, P> g1001(gx01.y, gy01.y, gz01.y, gw01.y);
+		vec<4, T, P> g0101(gx01.z, gy01.z, gz01.z, gw01.z);
+		vec<4, T, P> g1101(gx01.w, gy01.w, gz01.w, gw01.w);
+		vec<4, T, P> g0011(gx11.x, gy11.x, gz11.x, gw11.x);
+		vec<4, T, P> g1011(gx11.y, gy11.y, gz11.y, gw11.y);
+		vec<4, T, P> g0111(gx11.z, gy11.z, gz11.z, gw11.z);
+		vec<4, T, P> g1111(gx11.w, gy11.w, gz11.w, gw11.w);
 
-		tvec4<T, P> norm00 = detail::taylorInvSqrt(tvec4<T, P>(dot(g0000, g0000), dot(g0100, g0100), dot(g1000, g1000), dot(g1100, g1100)));
+		vec<4, T, P> norm00 = detail::taylorInvSqrt(vec<4, T, P>(dot(g0000, g0000), dot(g0100, g0100), dot(g1000, g1000), dot(g1100, g1100)));
 		g0000 *= norm00.x;
 		g0100 *= norm00.y;
 		g1000 *= norm00.z;
 		g1100 *= norm00.w;
 
-		tvec4<T, P> norm01 = detail::taylorInvSqrt(tvec4<T, P>(dot(g0001, g0001), dot(g0101, g0101), dot(g1001, g1001), dot(g1101, g1101)));
+		vec<4, T, P> norm01 = detail::taylorInvSqrt(vec<4, T, P>(dot(g0001, g0001), dot(g0101, g0101), dot(g1001, g1001), dot(g1101, g1101)));
 		g0001 *= norm01.x;
 		g0101 *= norm01.y;
 		g1001 *= norm01.z;
 		g1101 *= norm01.w;
 
-		tvec4<T, P> norm10 = detail::taylorInvSqrt(tvec4<T, P>(dot(g0010, g0010), dot(g0110, g0110), dot(g1010, g1010), dot(g1110, g1110)));
+		vec<4, T, P> norm10 = detail::taylorInvSqrt(vec<4, T, P>(dot(g0010, g0010), dot(g0110, g0110), dot(g1010, g1010), dot(g1110, g1110)));
 		g0010 *= norm10.x;
 		g0110 *= norm10.y;
 		g1010 *= norm10.z;
 		g1110 *= norm10.w;
 
-		tvec4<T, P> norm11 = detail::taylorInvSqrt(tvec4<T, P>(dot(g0011, g0011), dot(g0111, g0111), dot(g1011, g1011), dot(g1111, g1111)));
+		vec<4, T, P> norm11 = detail::taylorInvSqrt(vec<4, T, P>(dot(g0011, g0011), dot(g0111, g0111), dot(g1011, g1011), dot(g1111, g1111)));
 		g0011 *= norm11.x;
 		g0111 *= norm11.y;
 		g1011 *= norm11.z;
 		g1111 *= norm11.w;
 
 		T n0000 = dot(g0000, Pf0);
-		T n1000 = dot(g1000, tvec4<T, P>(Pf1.x, Pf0.y, Pf0.z, Pf0.w));
-		T n0100 = dot(g0100, tvec4<T, P>(Pf0.x, Pf1.y, Pf0.z, Pf0.w));
-		T n1100 = dot(g1100, tvec4<T, P>(Pf1.x, Pf1.y, Pf0.z, Pf0.w));
-		T n0010 = dot(g0010, tvec4<T, P>(Pf0.x, Pf0.y, Pf1.z, Pf0.w));
-		T n1010 = dot(g1010, tvec4<T, P>(Pf1.x, Pf0.y, Pf1.z, Pf0.w));
-		T n0110 = dot(g0110, tvec4<T, P>(Pf0.x, Pf1.y, Pf1.z, Pf0.w));
-		T n1110 = dot(g1110, tvec4<T, P>(Pf1.x, Pf1.y, Pf1.z, Pf0.w));
-		T n0001 = dot(g0001, tvec4<T, P>(Pf0.x, Pf0.y, Pf0.z, Pf1.w));
-		T n1001 = dot(g1001, tvec4<T, P>(Pf1.x, Pf0.y, Pf0.z, Pf1.w));
-		T n0101 = dot(g0101, tvec4<T, P>(Pf0.x, Pf1.y, Pf0.z, Pf1.w));
-		T n1101 = dot(g1101, tvec4<T, P>(Pf1.x, Pf1.y, Pf0.z, Pf1.w));
-		T n0011 = dot(g0011, tvec4<T, P>(Pf0.x, Pf0.y, Pf1.z, Pf1.w));
-		T n1011 = dot(g1011, tvec4<T, P>(Pf1.x, Pf0.y, Pf1.z, Pf1.w));
-		T n0111 = dot(g0111, tvec4<T, P>(Pf0.x, Pf1.y, Pf1.z, Pf1.w));
+		T n1000 = dot(g1000, vec<4, T, P>(Pf1.x, Pf0.y, Pf0.z, Pf0.w));
+		T n0100 = dot(g0100, vec<4, T, P>(Pf0.x, Pf1.y, Pf0.z, Pf0.w));
+		T n1100 = dot(g1100, vec<4, T, P>(Pf1.x, Pf1.y, Pf0.z, Pf0.w));
+		T n0010 = dot(g0010, vec<4, T, P>(Pf0.x, Pf0.y, Pf1.z, Pf0.w));
+		T n1010 = dot(g1010, vec<4, T, P>(Pf1.x, Pf0.y, Pf1.z, Pf0.w));
+		T n0110 = dot(g0110, vec<4, T, P>(Pf0.x, Pf1.y, Pf1.z, Pf0.w));
+		T n1110 = dot(g1110, vec<4, T, P>(Pf1.x, Pf1.y, Pf1.z, Pf0.w));
+		T n0001 = dot(g0001, vec<4, T, P>(Pf0.x, Pf0.y, Pf0.z, Pf1.w));
+		T n1001 = dot(g1001, vec<4, T, P>(Pf1.x, Pf0.y, Pf0.z, Pf1.w));
+		T n0101 = dot(g0101, vec<4, T, P>(Pf0.x, Pf1.y, Pf0.z, Pf1.w));
+		T n1101 = dot(g1101, vec<4, T, P>(Pf1.x, Pf1.y, Pf0.z, Pf1.w));
+		T n0011 = dot(g0011, vec<4, T, P>(Pf0.x, Pf0.y, Pf1.z, Pf1.w));
+		T n1011 = dot(g1011, vec<4, T, P>(Pf1.x, Pf0.y, Pf1.z, Pf1.w));
+		T n0111 = dot(g0111, vec<4, T, P>(Pf0.x, Pf1.y, Pf1.z, Pf1.w));
 		T n1111 = dot(g1111, Pf1);
 
-		tvec4<T, P> fade_xyzw = detail::fade(Pf0);
-		tvec4<T, P> n_0w = mix(tvec4<T, P>(n0000, n1000, n0100, n1100), tvec4<T, P>(n0001, n1001, n0101, n1101), fade_xyzw.w);
-		tvec4<T, P> n_1w = mix(tvec4<T, P>(n0010, n1010, n0110, n1110), tvec4<T, P>(n0011, n1011, n0111, n1111), fade_xyzw.w);
-		tvec4<T, P> n_zw = mix(n_0w, n_1w, fade_xyzw.z);
-		tvec2<T, P> n_yzw = mix(tvec2<T, P>(n_zw.x, n_zw.y), tvec2<T, P>(n_zw.z, n_zw.w), fade_xyzw.y);
+		vec<4, T, P> fade_xyzw = detail::fade(Pf0);
+		vec<4, T, P> n_0w = mix(vec<4, T, P>(n0000, n1000, n0100, n1100), vec<4, T, P>(n0001, n1001, n0101, n1101), fade_xyzw.w);
+		vec<4, T, P> n_1w = mix(vec<4, T, P>(n0010, n1010, n0110, n1110), vec<4, T, P>(n0011, n1011, n0111, n1111), fade_xyzw.w);
+		vec<4, T, P> n_zw = mix(n_0w, n_1w, fade_xyzw.z);
+		vec<2, T, P> n_yzw = mix(vec<2, T, P>(n_zw.x, n_zw.y), vec<2, T, P>(n_zw.z, n_zw.w), fade_xyzw.y);
 		T n_xyzw = mix(n_yzw.x, n_yzw.y, fade_xyzw.x);
 		return T(2.2) * n_xyzw;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER T simplex(glm::tvec2<T, P> const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER T simplex(glm::vec<2, T, P> const & v)
 	{
-		tvec4<T, P> const C = tvec4<T, P>(
+		vec<4, T, P> const C = vec<4, T, P>(
 			T( 0.211324865405187),  // (3.0 -  sqrt(3.0)) / 6.0
 			T( 0.366025403784439),  //  0.5 * (sqrt(3.0)  - 1.0)
 			T(-0.577350269189626),	// -1.0 + 2.0 * C.x
 			T( 0.024390243902439)); //  1.0 / 41.0
 
 		// First corner
-		tvec2<T, P> i  = floor(v + dot(v, tvec2<T, P>(C[1])));
-		tvec2<T, P> x0 = v -   i + dot(i, tvec2<T, P>(C[0]));
+		vec<2, T, P> i  = floor(v + dot(v, vec<2, T, P>(C[1])));
+		vec<2, T, P> x0 = v -   i + dot(i, vec<2, T, P>(C[0]));
 
 		// Other corners
 		//i1.x = step( x0.y, x0.x ); // x0.x > x0.y ? 1.0 : 0.0
 		//i1.y = 1.0 - i1.x;
-		tvec2<T, P> i1 = (x0.x > x0.y) ? tvec2<T, P>(1, 0) : tvec2<T, P>(0, 1);
+		vec<2, T, P> i1 = (x0.x > x0.y) ? vec<2, T, P>(1, 0) : vec<2, T, P>(0, 1);
 		// x0 = x0 - 0.0 + 0.0 * C.xx ;
 		// x1 = x0 - i1 + 1.0 * C.xx ;
 		// x2 = x0 - 1.0 + 2.0 * C.xx ;
-		tvec4<T, P> x12 = tvec4<T, P>(x0.x, x0.y, x0.x, x0.y) + tvec4<T, P>(C.x, C.x, C.z, C.z);
-		x12 = tvec4<T, P>(tvec2<T, P>(x12) - i1, x12.z, x12.w);
+		vec<4, T, P> x12 = vec<4, T, P>(x0.x, x0.y, x0.x, x0.y) + vec<4, T, P>(C.x, C.x, C.z, C.z);
+		x12 = vec<4, T, P>(vec<2, T, P>(x12) - i1, x12.z, x12.w);
 
 		// Permutations
-		i = mod(i, tvec2<T, P>(289)); // Avoid truncation effects in permutation
-		tvec3<T, P> p = detail::permute(
-			detail::permute(i.y + tvec3<T, P>(T(0), i1.y, T(1)))
-			+ i.x + tvec3<T, P>(T(0), i1.x, T(1)));
+		i = mod(i, vec<2, T, P>(289)); // Avoid truncation effects in permutation
+		vec<3, T, P> p = detail::permute(
+			detail::permute(i.y + vec<3, T, P>(T(0), i1.y, T(1)))
+			+ i.x + vec<3, T, P>(T(0), i1.x, T(1)));
 
-		tvec3<T, P> m = max(tvec3<T, P>(0.5) - tvec3<T, P>(
+		vec<3, T, P> m = max(vec<3, T, P>(0.5) - vec<3, T, P>(
 			dot(x0, x0),
-			dot(tvec2<T, P>(x12.x, x12.y), tvec2<T, P>(x12.x, x12.y)), 
-			dot(tvec2<T, P>(x12.z, x12.w), tvec2<T, P>(x12.z, x12.w))), tvec3<T, P>(0));
+			dot(vec<2, T, P>(x12.x, x12.y), vec<2, T, P>(x12.x, x12.y)), 
+			dot(vec<2, T, P>(x12.z, x12.w), vec<2, T, P>(x12.z, x12.w))), vec<3, T, P>(0));
 		m = m * m ;
 		m = m * m ;
 
 		// Gradients: 41 points uniformly over a line, mapped onto a diamond.
 		// The ring size 17*17 = 289 is close to a multiple of 41 (41*7 = 287)
 
-		tvec3<T, P> x = static_cast<T>(2) * fract(p * C.w) - T(1);
-		tvec3<T, P> h = abs(x) - T(0.5);
-		tvec3<T, P> ox = floor(x + T(0.5));
-		tvec3<T, P> a0 = x - ox;
+		vec<3, T, P> x = static_cast<T>(2) * fract(p * C.w) - T(1);
+		vec<3, T, P> h = abs(x) - T(0.5);
+		vec<3, T, P> ox = floor(x + T(0.5));
+		vec<3, T, P> a0 = x - ox;
 
 		// Normalise gradients implicitly by scaling m
 		// Inlined for speed: m *= taylorInvSqrt( a0*a0 + h*h );
 		m *= static_cast<T>(1.79284291400159) - T(0.85373472095314) * (a0 * a0 + h * h);
 
 		// Compute final noise value at P
-		tvec3<T, P> g;
+		vec<3, T, P> g;
 		g.x  = a0.x  * x0.x  + h.x  * x0.y;
 		//g.yz = a0.yz * x12.xz + h.yz * x12.yw;
 		g.y = a0.y * x12.x + h.y * x12.y;
@@ -645,85 +645,85 @@ namespace gtc
 		return T(130) * dot(m, g);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER T simplex(tvec3<T, P> const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER T simplex(vec<3, T, P> const & v)
 	{
-		tvec2<T, P> const C(1.0 / 6.0, 1.0 / 3.0);
-		tvec4<T, P> const D(0.0, 0.5, 1.0, 2.0);
+		vec<2, T, P> const C(1.0 / 6.0, 1.0 / 3.0);
+		vec<4, T, P> const D(0.0, 0.5, 1.0, 2.0);
 
 		// First corner
-		tvec3<T, P> i(floor(v + dot(v, tvec3<T, P>(C.y))));
-		tvec3<T, P> x0(v - i + dot(i, tvec3<T, P>(C.x)));
+		vec<3, T, P> i(floor(v + dot(v, vec<3, T, P>(C.y))));
+		vec<3, T, P> x0(v - i + dot(i, vec<3, T, P>(C.x)));
 
 		// Other corners
-		tvec3<T, P> g(step(tvec3<T, P>(x0.y, x0.z, x0.x), x0));
-		tvec3<T, P> l(T(1) - g);
-		tvec3<T, P> i1(min(g, tvec3<T, P>(l.z, l.x, l.y)));
-		tvec3<T, P> i2(max(g, tvec3<T, P>(l.z, l.x, l.y)));
+		vec<3, T, P> g(step(vec<3, T, P>(x0.y, x0.z, x0.x), x0));
+		vec<3, T, P> l(T(1) - g);
+		vec<3, T, P> i1(min(g, vec<3, T, P>(l.z, l.x, l.y)));
+		vec<3, T, P> i2(max(g, vec<3, T, P>(l.z, l.x, l.y)));
 
 		//   x0 = x0 - 0.0 + 0.0 * C.xxx;
 		//   x1 = x0 - i1  + 1.0 * C.xxx;
 		//   x2 = x0 - i2  + 2.0 * C.xxx;
 		//   x3 = x0 - 1.0 + 3.0 * C.xxx;
-		tvec3<T, P> x1(x0 - i1 + C.x);
-		tvec3<T, P> x2(x0 - i2 + C.y); // 2.0*C.x = 1/3 = C.y
-		tvec3<T, P> x3(x0 - D.y);      // -1.0+3.0*C.x = -0.5 = -D.y
+		vec<3, T, P> x1(x0 - i1 + C.x);
+		vec<3, T, P> x2(x0 - i2 + C.y); // 2.0*C.x = 1/3 = C.y
+		vec<3, T, P> x3(x0 - D.y);      // -1.0+3.0*C.x = -0.5 = -D.y
 
 		// Permutations
 		i = detail::mod289(i);
-		tvec4<T, P> p(detail::permute(detail::permute(detail::permute(
-			i.z + tvec4<T, P>(T(0), i1.z, i2.z, T(1))) +
-			i.y + tvec4<T, P>(T(0), i1.y, i2.y, T(1))) +
-			i.x + tvec4<T, P>(T(0), i1.x, i2.x, T(1))));
+		vec<4, T, P> p(detail::permute(detail::permute(detail::permute(
+			i.z + vec<4, T, P>(T(0), i1.z, i2.z, T(1))) +
+			i.y + vec<4, T, P>(T(0), i1.y, i2.y, T(1))) +
+			i.x + vec<4, T, P>(T(0), i1.x, i2.x, T(1))));
 
 		// Gradients: 7x7 points over a square, mapped onto an octahedron.
 		// The ring size 17*17 = 289 is close to a multiple of 49 (49*6 = 294)
 		T n_ = static_cast<T>(0.142857142857); // 1.0/7.0
-		tvec3<T, P> ns(n_ * tvec3<T, P>(D.w, D.y, D.z) - tvec3<T, P>(D.x, D.z, D.x));
+		vec<3, T, P> ns(n_ * vec<3, T, P>(D.w, D.y, D.z) - vec<3, T, P>(D.x, D.z, D.x));
 
-		tvec4<T, P> j(p - T(49) * floor(p * ns.z * ns.z));  //  mod(p,7*7)
+		vec<4, T, P> j(p - T(49) * floor(p * ns.z * ns.z));  //  mod(p,7*7)
 
-		tvec4<T, P> x_(floor(j * ns.z));
-		tvec4<T, P> y_(floor(j - T(7) * x_));    // mod(j,N)
+		vec<4, T, P> x_(floor(j * ns.z));
+		vec<4, T, P> y_(floor(j - T(7) * x_));    // mod(j,N)
 
-		tvec4<T, P> x(x_ * ns.x + ns.y);
-		tvec4<T, P> y(y_ * ns.x + ns.y);
-		tvec4<T, P> h(T(1) - abs(x) - abs(y));
+		vec<4, T, P> x(x_ * ns.x + ns.y);
+		vec<4, T, P> y(y_ * ns.x + ns.y);
+		vec<4, T, P> h(T(1) - abs(x) - abs(y));
 
-		tvec4<T, P> b0(x.x, x.y, y.x, y.y);
-		tvec4<T, P> b1(x.z, x.w, y.z, y.w);
+		vec<4, T, P> b0(x.x, x.y, y.x, y.y);
+		vec<4, T, P> b1(x.z, x.w, y.z, y.w);
 
 		// vec4 s0 = vec4(lessThan(b0,0.0))*2.0 - 1.0;
 		// vec4 s1 = vec4(lessThan(b1,0.0))*2.0 - 1.0;
-		tvec4<T, P> s0(floor(b0) * T(2) + T(1));
-		tvec4<T, P> s1(floor(b1) * T(2) + T(1));
-		tvec4<T, P> sh(-step(h, tvec4<T, P>(0.0)));
+		vec<4, T, P> s0(floor(b0) * T(2) + T(1));
+		vec<4, T, P> s1(floor(b1) * T(2) + T(1));
+		vec<4, T, P> sh(-step(h, vec<4, T, P>(0.0)));
 
-		tvec4<T, P> a0 = tvec4<T, P>(b0.x, b0.z, b0.y, b0.w) + tvec4<T, P>(s0.x, s0.z, s0.y, s0.w) * tvec4<T, P>(sh.x, sh.x, sh.y, sh.y);
-		tvec4<T, P> a1 = tvec4<T, P>(b1.x, b1.z, b1.y, b1.w) + tvec4<T, P>(s1.x, s1.z, s1.y, s1.w) * tvec4<T, P>(sh.z, sh.z, sh.w, sh.w);
+		vec<4, T, P> a0 = vec<4, T, P>(b0.x, b0.z, b0.y, b0.w) + vec<4, T, P>(s0.x, s0.z, s0.y, s0.w) * vec<4, T, P>(sh.x, sh.x, sh.y, sh.y);
+		vec<4, T, P> a1 = vec<4, T, P>(b1.x, b1.z, b1.y, b1.w) + vec<4, T, P>(s1.x, s1.z, s1.y, s1.w) * vec<4, T, P>(sh.z, sh.z, sh.w, sh.w);
 
-		tvec3<T, P> p0(a0.x, a0.y, h.x);
-		tvec3<T, P> p1(a0.z, a0.w, h.y);
-		tvec3<T, P> p2(a1.x, a1.y, h.z);
-		tvec3<T, P> p3(a1.z, a1.w, h.w);
+		vec<3, T, P> p0(a0.x, a0.y, h.x);
+		vec<3, T, P> p1(a0.z, a0.w, h.y);
+		vec<3, T, P> p2(a1.x, a1.y, h.z);
+		vec<3, T, P> p3(a1.z, a1.w, h.w);
 
 		// Normalise gradients
-		tvec4<T, P> norm = detail::taylorInvSqrt(tvec4<T, P>(dot(p0, p0), dot(p1, p1), dot(p2, p2), dot(p3, p3)));
+		vec<4, T, P> norm = detail::taylorInvSqrt(vec<4, T, P>(dot(p0, p0), dot(p1, p1), dot(p2, p2), dot(p3, p3)));
 		p0 *= norm.x;
 		p1 *= norm.y;
 		p2 *= norm.z;
 		p3 *= norm.w;
 
 		// Mix final noise value
-		tvec4<T, P> m = max(T(0.6) - tvec4<T, P>(dot(x0, x0), dot(x1, x1), dot(x2, x2), dot(x3, x3)), tvec4<T, P>(0));
+		vec<4, T, P> m = max(T(0.6) - vec<4, T, P>(dot(x0, x0), dot(x1, x1), dot(x2, x2), dot(x3, x3)), vec<4, T, P>(0));
 		m = m * m;
-		return T(42) * dot(m * m, tvec4<T, P>(dot(p0, x0), dot(p1, x1), dot(p2, x2), dot(p3, x3)));
+		return T(42) * dot(m * m, vec<4, T, P>(dot(p0, x0), dot(p1, x1), dot(p2, x2), dot(p3, x3)));
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER T simplex(tvec4<T, P> const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER T simplex(vec<4, T, P> const & v)
 	{
-		tvec4<T, P> const C(
+		vec<4, T, P> const C(
 			0.138196601125011,  // (5 - sqrt(5))/20  G4
 			0.276393202250021,  // 2 * G4
 			0.414589803375032,  // 3 * G4
@@ -733,63 +733,63 @@ namespace gtc
 		T const F4 = static_cast<T>(0.309016994374947451);
 
 		// First corner
-		tvec4<T, P> i  = floor(v + dot(v, vec4(F4)));
-		tvec4<T, P> x0 = v -   i + dot(i, vec4(C.x));
+		vec<4, T, P> i  = floor(v + dot(v, vec4(F4)));
+		vec<4, T, P> x0 = v -   i + dot(i, vec4(C.x));
 
 		// Other corners
 
 		// Rank sorting originally contributed by Bill Licea-Kane, AMD (formerly ATI)
-		tvec4<T, P> i0;
-		tvec3<T, P> isX = step(tvec3<T, P>(x0.y, x0.z, x0.w), tvec3<T, P>(x0.x));
-		tvec3<T, P> isYZ = step(tvec3<T, P>(x0.z, x0.w, x0.w), tvec3<T, P>(x0.y, x0.y, x0.z));
+		vec<4, T, P> i0;
+		vec<3, T, P> isX = step(vec<3, T, P>(x0.y, x0.z, x0.w), vec<3, T, P>(x0.x));
+		vec<3, T, P> isYZ = step(vec<3, T, P>(x0.z, x0.w, x0.w), vec<3, T, P>(x0.y, x0.y, x0.z));
 		//  i0.x = dot(isX, vec3(1.0));
 		//i0.x = isX.x + isX.y + isX.z;
 		//i0.yzw = static_cast<T>(1) - isX;
-		i0 = tvec4<T, P>(isX.x + isX.y + isX.z, T(1) - isX);
+		i0 = vec<4, T, P>(isX.x + isX.y + isX.z, T(1) - isX);
 		//  i0.y += dot(isYZ.xy, vec2(1.0));
 		i0.y += isYZ.x + isYZ.y;
-		//i0.zw += 1.0 - tvec2<T, P>(isYZ.x, isYZ.y);
+		//i0.zw += 1.0 - vec<2, T, P>(isYZ.x, isYZ.y);
 		i0.z += static_cast<T>(1) - isYZ.x;
 		i0.w += static_cast<T>(1) - isYZ.y;
 		i0.z += isYZ.z;
 		i0.w += static_cast<T>(1) - isYZ.z;
 
 		// i0 now contains the unique values 0,1,2,3 in each channel
-		tvec4<T, P> i3 = clamp(i0, T(0), T(1));
-		tvec4<T, P> i2 = clamp(i0 - T(1), T(0), T(1));
-		tvec4<T, P> i1 = clamp(i0 - T(2), T(0), T(1));
+		vec<4, T, P> i3 = clamp(i0, T(0), T(1));
+		vec<4, T, P> i2 = clamp(i0 - T(1), T(0), T(1));
+		vec<4, T, P> i1 = clamp(i0 - T(2), T(0), T(1));
 
 		//  x0 = x0 - 0.0 + 0.0 * C.xxxx
 		//  x1 = x0 - i1  + 0.0 * C.xxxx
 		//  x2 = x0 - i2  + 0.0 * C.xxxx
 		//  x3 = x0 - i3  + 0.0 * C.xxxx
 		//  x4 = x0 - 1.0 + 4.0 * C.xxxx
-		tvec4<T, P> x1 = x0 - i1 + C.x;
-		tvec4<T, P> x2 = x0 - i2 + C.y;
-		tvec4<T, P> x3 = x0 - i3 + C.z;
-		tvec4<T, P> x4 = x0 + C.w;
+		vec<4, T, P> x1 = x0 - i1 + C.x;
+		vec<4, T, P> x2 = x0 - i2 + C.y;
+		vec<4, T, P> x3 = x0 - i3 + C.z;
+		vec<4, T, P> x4 = x0 + C.w;
 
 		// Permutations
-		i = mod(i, tvec4<T, P>(289)); 
+		i = mod(i, vec<4, T, P>(289)); 
 		T j0 = detail::permute(detail::permute(detail::permute(detail::permute(i.w) + i.z) + i.y) + i.x);
-		tvec4<T, P> j1 = detail::permute(detail::permute(detail::permute(detail::permute(
-			i.w + tvec4<T, P>(i1.w, i2.w, i3.w, T(1))) +
-			i.z + tvec4<T, P>(i1.z, i2.z, i3.z, T(1))) +
-			i.y + tvec4<T, P>(i1.y, i2.y, i3.y, T(1))) +
-			i.x + tvec4<T, P>(i1.x, i2.x, i3.x, T(1)));
+		vec<4, T, P> j1 = detail::permute(detail::permute(detail::permute(detail::permute(
+			i.w + vec<4, T, P>(i1.w, i2.w, i3.w, T(1))) +
+			i.z + vec<4, T, P>(i1.z, i2.z, i3.z, T(1))) +
+			i.y + vec<4, T, P>(i1.y, i2.y, i3.y, T(1))) +
+			i.x + vec<4, T, P>(i1.x, i2.x, i3.x, T(1)));
 
 		// Gradients: 7x7x6 points over a cube, mapped onto a 4-cross polytope
 		// 7*7*6 = 294, which is close to the ring size 17*17 = 289.
-		tvec4<T, P> ip = tvec4<T, P>(T(1) / T(294), T(1) / T(49), T(1) / T(7), T(0));
+		vec<4, T, P> ip = vec<4, T, P>(T(1) / T(294), T(1) / T(49), T(1) / T(7), T(0));
 
-		tvec4<T, P> p0 = gtc::grad4(j0,   ip);
-		tvec4<T, P> p1 = gtc::grad4(j1.x, ip);
-		tvec4<T, P> p2 = gtc::grad4(j1.y, ip);
-		tvec4<T, P> p3 = gtc::grad4(j1.z, ip);
-		tvec4<T, P> p4 = gtc::grad4(j1.w, ip);
+		vec<4, T, P> p0 = gtc::grad4(j0,   ip);
+		vec<4, T, P> p1 = gtc::grad4(j1.x, ip);
+		vec<4, T, P> p2 = gtc::grad4(j1.y, ip);
+		vec<4, T, P> p3 = gtc::grad4(j1.z, ip);
+		vec<4, T, P> p4 = gtc::grad4(j1.w, ip);
 
 		// Normalise gradients
-		tvec4<T, P> norm = detail::taylorInvSqrt(tvec4<T, P>(dot(p0, p0), dot(p1, p1), dot(p2, p2), dot(p3, p3)));
+		vec<4, T, P> norm = detail::taylorInvSqrt(vec<4, T, P>(dot(p0, p0), dot(p1, p1), dot(p2, p2), dot(p3, p3)));
 		p0 *= norm.x;
 		p1 *= norm.y;
 		p2 *= norm.z;
@@ -797,12 +797,12 @@ namespace gtc
 		p4 *= detail::taylorInvSqrt(dot(p4, p4));
 
 		// Mix contributions from the five corners
-		tvec3<T, P> m0 = max(T(0.6) - tvec3<T, P>(dot(x0, x0), dot(x1, x1), dot(x2, x2)), tvec3<T, P>(0));
-		tvec2<T, P> m1 = max(T(0.6) - tvec2<T, P>(dot(x3, x3), dot(x4, x4)             ), tvec2<T, P>(0));
+		vec<3, T, P> m0 = max(T(0.6) - vec<3, T, P>(dot(x0, x0), dot(x1, x1), dot(x2, x2)), vec<3, T, P>(0));
+		vec<2, T, P> m1 = max(T(0.6) - vec<2, T, P>(dot(x3, x3), dot(x4, x4)             ), vec<2, T, P>(0));
 		m0 = m0 * m0;
 		m1 = m1 * m1;
 		return T(49) * 
-			(dot(m0 * m0, tvec3<T, P>(dot(p0, x0), dot(p1, x1), dot(p2, x2))) + 
-			dot(m1 * m1, tvec2<T, P>(dot(p3, x3), dot(p4, x4))));
+			(dot(m0 * m0, vec<3, T, P>(dot(p0, x0), dot(p1, x1), dot(p2, x2))) + 
+			dot(m1 * m1, vec<2, T, P>(dot(p3, x3), dot(p4, x4))));
 	}
 }//namespace glm
diff --git a/glm/gtc/packing.hpp b/glm/gtc/packing.hpp
index 7cae3222..59595648 100644
--- a/glm/gtc/packing.hpp
+++ b/glm/gtc/packing.hpp
@@ -475,20 +475,20 @@ namespace glm
 	/// the forth component specifies the 16 most-significant bits.
 	/// 
 	/// @see gtc_packing
-	/// @see tvec3<T, P> unpackRGBM(tvec4<T, P> const & p)
+	/// @see vec<3, T, P> unpackRGBM(vec<4, T, P> const & p)
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec4<T, P> packRGBM(tvec3<T, P> const & rgb);
+	template<length_t L, typename T, precision P>
+	GLM_FUNC_DECL vec<4, T, P> packRGBM(vec<3, T, P> const & rgb);
 
 	/// Returns a floating-point vector with components obtained by reinterpreting an integer vector as 16-bit floating-point numbers and converting them to 32-bit floating-point values.
 	/// The first component of the vector is obtained from the 16 least-significant bits of v;
 	/// the forth component is obtained from the 16 most-significant bits of v.
 	/// 
 	/// @see gtc_packing
-	/// @see tvec4<T, P> packRGBM(tvec3<float, P> const & v)
+	/// @see vec<4, T, P> packRGBM(vec<3, float, P> const & v)
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> unpackRGBM(tvec4<T, P> const & rgbm);
+	template<length_t L, typename T, precision P>
+	GLM_FUNC_DECL vec<3, T, P> unpackRGBM(vec<4, T, P> const & rgbm);
 
 	/// Returns an unsigned integer vector obtained by converting the components of a floating-point vector
 	/// to the 16-bit floating-point representation found in the OpenGL Specification.
@@ -496,48 +496,48 @@ namespace glm
 	/// the forth component specifies the 16 most-significant bits.
 	/// 
 	/// @see gtc_packing
-	/// @see vecType<float, P> unpackHalf(vecType<uint16, P> const & p)
+	/// @see vecType<L, float, P> unpackHalf(vecType<L, uint16, P> const & p)
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
-	template <precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<uint16, P> packHalf(vecType<float, P> const & v);
+	template<length_t L, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, uint16, P> packHalf(vecType<L, float, P> const & v);
 
 	/// Returns a floating-point vector with components obtained by reinterpreting an integer vector as 16-bit floating-point numbers and converting them to 32-bit floating-point values.
 	/// The first component of the vector is obtained from the 16 least-significant bits of v;
 	/// the forth component is obtained from the 16 most-significant bits of v.
 	/// 
 	/// @see gtc_packing
-	/// @see vecType<uint16, P> packHalf(vecType<float, P> const & v)
+	/// @see vecType<L, uint16, P> packHalf(vecType<L, float, P> const & v)
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
-	template <precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<float, P> unpackHalf(vecType<uint16, P> const & p);
+	template<length_t L, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, float, P> unpackHalf(vecType<L, uint16, P> const & p);
 
 	/// Convert each component of the normalized floating-point vector into unsigned integer values.
 	///
 	/// @see gtc_packing
-	/// @see vecType<floatType, P> unpackUnorm(vecType<intType, P> const & p);
-	template <typename uintType, typename floatType, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<uintType, P> packUnorm(vecType<floatType, P> const & v);
+	/// @see vecType<L, floatType, P> unpackUnorm(vecType<L, intType, P> const & p);
+	template<typename uintType, length_t L, typename floatType, precision P>
+	GLM_FUNC_DECL vec<L, uintType, P> packUnorm(vec<L, floatType, P> const & v);
 
 	/// Convert each unsigned integer components of a vector to normalized floating-point values.
 	/// 
 	/// @see gtc_packing
-	/// @see vecType<intType, P> packUnorm(vecType<floatType, P> const & v)
-	template <typename uintType, typename floatType, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<floatType, P> unpackUnorm(vecType<uintType, P> const & v);
+	/// @see vecType<L, intType, P> packUnorm(vecType<L, floatType, P> const & v)
+	template<typename floatType, length_t L, typename uintType, precision P>
+	GLM_FUNC_DECL vec<L, floatType, P> unpackUnorm(vec<L, uintType, P> const & v);
 
 	/// Convert each component of the normalized floating-point vector into signed integer values.
 	///
 	/// @see gtc_packing
-	/// @see vecType<floatType, P> unpackSnorm(vecType<intType, P> const & p);
-	template <typename intType, typename floatType, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<intType, P> packSnorm(vecType<floatType, P> const & v);
+	/// @see vecType<L, floatType, P> unpackSnorm(vecType<L, intType, P> const & p);
+	template<typename intType, length_t L, typename floatType, precision P>
+	GLM_FUNC_DECL vec<L, intType, P> packSnorm(vec<L, floatType, P> const & v);
 
 	/// Convert each signed integer components of a vector to normalized floating-point values.
 	/// 
 	/// @see gtc_packing
-	/// @see vecType<intType, P> packSnorm(vecType<floatType, P> const & v)
-	template <typename intType, typename floatType, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<floatType, P> unpackSnorm(vecType<intType, P> const & v);
+	/// @see vecType<L, intType, P> packSnorm(vecType<L, floatType, P> const & v)
+	template<typename floatType, length_t L, typename intType, precision P>
+	GLM_FUNC_DECL vec<L, floatType, P> unpackSnorm(vec<L, intType, P> const & v);
 
 	/// Convert each component of the normalized floating-point vector into unsigned integer values.
 	///
diff --git a/glm/gtc/packing.inl b/glm/gtc/packing.inl
index 032ecd88..df744b2f 100644
--- a/glm/gtc/packing.inl
+++ b/glm/gtc/packing.inl
@@ -270,14 +270,14 @@ namespace detail
 		uint32 pack;
 	};
 
-	template <precision P, template <typename, precision> class vecType>
+	template<length_t L, precision P, template<length_t, typename, precision> class vecType>
 	struct compute_half
 	{};
 
-	template <precision P>
-	struct compute_half<P, tvec1>
+	template<precision P>
+	struct compute_half<1, P, vec>
 	{
-		GLM_FUNC_QUALIFIER static tvec1<uint16, P> pack(tvec1<float, P> const & v)
+		GLM_FUNC_QUALIFIER static vec<1, uint16, P> pack(vec<1, float, P> const & v)
 		{
 			int16 const Unpack(detail::toFloat16(v.x));
 			u16vec1 Packed(uninitialize);
@@ -285,68 +285,68 @@ namespace detail
 			return Packed;
 		}
 
-		GLM_FUNC_QUALIFIER static tvec1<float, P> unpack(tvec1<uint16, P> const & v)
+		GLM_FUNC_QUALIFIER static vec<1, float, P> unpack(vec<1, uint16, P> const & v)
 		{
 			i16vec1 Unpack(uninitialize);
 			memcpy(&Unpack, &v, sizeof(Unpack));
-			return tvec1<float, P>(detail::toFloat32(v.x));
+			return vec<1, float, P>(detail::toFloat32(v.x));
 		}
 	};
 
-	template <precision P>
-	struct compute_half<P, tvec2>
+	template<precision P>
+	struct compute_half<2, P, vec>
 	{
-		GLM_FUNC_QUALIFIER static tvec2<uint16, P> pack(tvec2<float, P> const & v)
+		GLM_FUNC_QUALIFIER static vec<2, uint16, P> pack(vec<2, float, P> const & v)
 		{
-			tvec2<int16, P> const Unpack(detail::toFloat16(v.x), detail::toFloat16(v.y));
+			vec<2, int16, P> const Unpack(detail::toFloat16(v.x), detail::toFloat16(v.y));
 			u16vec2 Packed(uninitialize);
 			memcpy(&Packed, &Unpack, sizeof(Packed));
 			return Packed;
 		}
 
-		GLM_FUNC_QUALIFIER static tvec2<float, P> unpack(tvec2<uint16, P> const & v)
+		GLM_FUNC_QUALIFIER static vec<2, float, P> unpack(vec<2, uint16, P> const & v)
 		{
 			i16vec2 Unpack(uninitialize);
 			memcpy(&Unpack, &v, sizeof(Unpack));
-			return tvec2<float, P>(detail::toFloat32(v.x), detail::toFloat32(v.y));
+			return vec<2, float, P>(detail::toFloat32(v.x), detail::toFloat32(v.y));
 		}
 	};
 
-	template <precision P>
-	struct compute_half<P, tvec3>
+	template<precision P>
+	struct compute_half<3, P, vec>
 	{
-		GLM_FUNC_QUALIFIER static tvec3<uint16, P> pack(tvec3<float, P> const & v)
+		GLM_FUNC_QUALIFIER static vec<3, uint16, P> pack(vec<3, float, P> const & v)
 		{
-			tvec3<int16, P> const Unpack(detail::toFloat16(v.x), detail::toFloat16(v.y), detail::toFloat16(v.z));
+			vec<3, int16, P> const Unpack(detail::toFloat16(v.x), detail::toFloat16(v.y), detail::toFloat16(v.z));
 			u16vec3 Packed(uninitialize);
 			memcpy(&Packed, &Unpack, sizeof(Packed));
 			return Packed;
 		}
 
-		GLM_FUNC_QUALIFIER static tvec3<float, P> unpack(tvec3<uint16, P> const & v)
+		GLM_FUNC_QUALIFIER static vec<3, float, P> unpack(vec<3, uint16, P> const & v)
 		{
 			i16vec3 Unpack(uninitialize);
 			memcpy(&Unpack, &v, sizeof(Unpack));
-			return tvec3<float, P>(detail::toFloat32(v.x), detail::toFloat32(v.y), detail::toFloat32(v.z));
+			return vec<3, float, P>(detail::toFloat32(v.x), detail::toFloat32(v.y), detail::toFloat32(v.z));
 		}
 	};
 
-	template <precision P>
-	struct compute_half<P, tvec4>
+	template<precision P>
+	struct compute_half<4, P, vec>
 	{
-		GLM_FUNC_QUALIFIER static tvec4<uint16, P> pack(tvec4<float, P> const & v)
+		GLM_FUNC_QUALIFIER static vec<4, uint16, P> pack(vec<4, float, P> const & v)
 		{
-			tvec4<int16, P> const Unpack(detail::toFloat16(v.x), detail::toFloat16(v.y), detail::toFloat16(v.z), detail::toFloat16(v.w));
+			vec<4, int16, P> const Unpack(detail::toFloat16(v.x), detail::toFloat16(v.y), detail::toFloat16(v.z), detail::toFloat16(v.w));
 			u16vec4 Packed(uninitialize);
 			memcpy(&Packed, &Unpack, sizeof(Packed));
 			return Packed;
 		}
 
-		GLM_FUNC_QUALIFIER static tvec4<float, P> unpack(tvec4<uint16, P> const & v)
+		GLM_FUNC_QUALIFIER static vec<4, float, P> unpack(vec<4, uint16, P> const & v)
 		{
 			i16vec4 Unpack(uninitialize);
 			memcpy(&Unpack, &v, sizeof(Unpack));
-			return tvec4<float, P>(detail::toFloat32(v.x), detail::toFloat32(v.y), detail::toFloat32(v.z), detail::toFloat32(v.w));
+			return vec<4, float, P>(detail::toFloat32(v.x), detail::toFloat32(v.y), detail::toFloat32(v.z), detail::toFloat32(v.w));
 		}
 	};
 }//namespace detail
@@ -640,67 +640,67 @@ namespace detail
 	}
 
 	// Based on Brian Karis http://graphicrants.blogspot.fr/2009/04/rgbm-color-encoding.html
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> packRGBM(tvec3<T, P> const & rgb)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, T, P> packRGBM(vec<3, T, P> const & rgb)
 	{
-		tvec3<T, P> const Color(rgb * static_cast<T>(1.0 / 6.0));
+		vec<3, T, P> const Color(rgb * static_cast<T>(1.0 / 6.0));
 		T Alpha = clamp(max(max(Color.x, Color.y), max(Color.z, static_cast<T>(1e-6))), static_cast<T>(0), static_cast<T>(1));
 		Alpha = ceil(Alpha * static_cast<T>(255.0)) / static_cast<T>(255.0);
-		return tvec4<T, P>(Color / Alpha, Alpha);
+		return vec<4, T, P>(Color / Alpha, Alpha);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> unpackRGBM(tvec4<T, P> const & rgbm)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> unpackRGBM(vec<4, T, P> const & rgbm)
 	{
-		return tvec3<T, P>(rgbm.x, rgbm.y, rgbm.z) * rgbm.w * static_cast<T>(6);
+		return vec<3, T, P>(rgbm.x, rgbm.y, rgbm.z) * rgbm.w * static_cast<T>(6);
 	}
 
-	template <precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<uint16, P> packHalf(vecType<float, P> const & v)
+	template<length_t L, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, uint16, P> packHalf(vecType<L, float, P> const & v)
 	{
-		return detail::compute_half<P, vecType>::pack(v);
+		return detail::compute_half<L, P, vecType>::pack(v);
 	}
 
-	template <precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<float, P> unpackHalf(vecType<uint16, P> const & v)
+	template<length_t L, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, float, P> unpackHalf(vecType<L, uint16, P> const & v)
 	{
-		return detail::compute_half<P, vecType>::unpack(v);
+		return detail::compute_half<L, P, vecType>::unpack(v);
 	}
 
-	template <typename uintType, typename floatType, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<uintType, P> packUnorm(vecType<floatType, P> const & v)
+	template<typename uintType, length_t L, typename floatType, precision P>
+	GLM_FUNC_QUALIFIER vec<L, uintType, P> packUnorm(vec<L, floatType, P> const& v)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<uintType>::is_integer, "uintType must be an integer type");
 		GLM_STATIC_ASSERT(std::numeric_limits<floatType>::is_iec559, "floatType must be a floating point type");
 
-		return vecType<uintType, P>(round(clamp(v, static_cast<floatType>(0), static_cast<floatType>(1)) * static_cast<floatType>(std::numeric_limits<uintType>::max())));
+		return vec<L, uintType, P>(round(clamp(v, static_cast<floatType>(0), static_cast<floatType>(1)) * static_cast<floatType>(std::numeric_limits<uintType>::max())));
 	}
 
-	template <typename uintType, typename floatType, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<floatType, P> unpackUnorm(vecType<uintType, P> const & v)
+	template<typename floatType, length_t L, typename uintType, precision P>
+	GLM_FUNC_QUALIFIER vec<L, floatType, P> unpackUnorm(vec<L, uintType, P> const& v)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<uintType>::is_integer, "uintType must be an integer type");
 		GLM_STATIC_ASSERT(std::numeric_limits<floatType>::is_iec559, "floatType must be a floating point type");
 
-		return vecType<float, P>(v) * (static_cast<floatType>(1) / static_cast<floatType>(std::numeric_limits<uintType>::max()));
+		return vec<L, float, P>(v) * (static_cast<floatType>(1) / static_cast<floatType>(std::numeric_limits<uintType>::max()));
 	}
 
-	template <typename intType, typename floatType, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<intType, P> packSnorm(vecType<floatType, P> const & v)
+	template<typename intType, length_t L, typename floatType, precision P>
+	GLM_FUNC_QUALIFIER vec<L, intType, P> packSnorm(vec<L, floatType, P> const & v)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<intType>::is_integer, "uintType must be an integer type");
 		GLM_STATIC_ASSERT(std::numeric_limits<floatType>::is_iec559, "floatType must be a floating point type");
 
-		return vecType<intType, P>(round(clamp(v , static_cast<floatType>(-1), static_cast<floatType>(1)) * static_cast<floatType>(std::numeric_limits<intType>::max())));
+		return vec<L, intType, P>(round(clamp(v , static_cast<floatType>(-1), static_cast<floatType>(1)) * static_cast<floatType>(std::numeric_limits<intType>::max())));
 	}
 
-	template <typename intType, typename floatType, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<floatType, P> unpackSnorm(vecType<intType, P> const & v)
+	template<typename floatType, length_t L, typename intType, precision P>
+	GLM_FUNC_QUALIFIER vec<L, floatType, P> unpackSnorm(vec<L, intType, P> const & v)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<intType>::is_integer, "uintType must be an integer type");
 		GLM_STATIC_ASSERT(std::numeric_limits<floatType>::is_iec559, "floatType must be a floating point type");
 
-		return clamp(vecType<floatType, P>(v) * (static_cast<floatType>(1) / static_cast<floatType>(std::numeric_limits<intType>::max())), static_cast<floatType>(-1), static_cast<floatType>(1));
+		return clamp(vec<L, floatType, P>(v) * (static_cast<floatType>(1) / static_cast<floatType>(std::numeric_limits<intType>::max())), static_cast<floatType>(-1), static_cast<floatType>(1));
 	}
 
 	GLM_FUNC_QUALIFIER uint8 packUnorm2x4(vec2 const & v)
diff --git a/glm/gtc/quaternion.hpp b/glm/gtc/quaternion.hpp
index 7a59702a..2486d4db 100644
--- a/glm/gtc/quaternion.hpp
+++ b/glm/gtc/quaternion.hpp
@@ -29,7 +29,7 @@ namespace glm
 	/// @addtogroup gtc_quaternion
 	/// @{
 
-	template <typename T, precision P = defaultp>
+	template<typename T, precision P = defaultp>
 	struct tquat
 	{
 		// -- Implementation detail --
@@ -79,24 +79,24 @@ namespace glm
 
 		GLM_FUNC_DECL GLM_CONSTEXPR tquat() GLM_DEFAULT_CTOR;
 		GLM_FUNC_DECL GLM_CONSTEXPR tquat(tquat<T, P> const & q) GLM_DEFAULT;
-		template <precision Q>
+		template<precision Q>
 		GLM_FUNC_DECL GLM_CONSTEXPR tquat(tquat<T, Q> const & q);
 
 		// -- Explicit basic constructors --
 
 		GLM_FUNC_DECL GLM_CONSTEXPR_CTOR explicit tquat(ctor);
-		GLM_FUNC_DECL GLM_CONSTEXPR tquat(T const & s, tvec3<T, P> const & v);
+		GLM_FUNC_DECL GLM_CONSTEXPR tquat(T const & s, vec<3, T, P> const & v);
 		GLM_FUNC_DECL GLM_CONSTEXPR tquat(T const & w, T const & x, T const & y, T const & z);
 
 		// -- Conversion constructors --
 
-		template <typename U, precision Q>
+		template<typename U, precision Q>
 		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tquat(tquat<U, Q> const & q);
 
 		/// Explicit conversion operators
 #		if GLM_HAS_EXPLICIT_CONVERSION_OPERATORS
-			GLM_FUNC_DECL explicit operator tmat3x3<T, P>();
-			GLM_FUNC_DECL explicit operator tmat4x4<T, P>();
+			GLM_FUNC_DECL explicit operator mat<3, 3, T, P>();
+			GLM_FUNC_DECL explicit operator mat<4, 4, T, P>();
 #		endif
 
 		/// Create a quaternion from two normalized axis
@@ -105,93 +105,93 @@ namespace glm
 		/// @param v A second normalized axis
 		/// @see gtc_quaternion
 		/// @see http://lolengine.net/blog/2013/09/18/beautiful-maths-quaternion-from-vectors
-		GLM_FUNC_DECL tquat(tvec3<T, P> const & u, tvec3<T, P> const & v);
+		GLM_FUNC_DECL tquat(vec<3, T, P> const & u, vec<3, T, P> const & v);
 
 		/// Build a quaternion from euler angles (pitch, yaw, roll), in radians.
-		GLM_FUNC_DECL GLM_EXPLICIT tquat(tvec3<T, P> const & eulerAngles);
-		GLM_FUNC_DECL GLM_EXPLICIT tquat(tmat3x3<T, P> const & m);
-		GLM_FUNC_DECL GLM_EXPLICIT tquat(tmat4x4<T, P> const & m);
+		GLM_FUNC_DECL GLM_EXPLICIT tquat(vec<3, T, P> const & eulerAngles);
+		GLM_FUNC_DECL GLM_EXPLICIT tquat(mat<3, 3, T, P> const & m);
+		GLM_FUNC_DECL GLM_EXPLICIT tquat(mat<4, 4, T, P> const & m);
 
 		// -- Unary arithmetic operators --
 
 		GLM_FUNC_DECL tquat<T, P> & operator=(tquat<T, P> const & m) GLM_DEFAULT;
 
-		template <typename U>
+		template<typename U>
 		GLM_FUNC_DECL tquat<T, P> & operator=(tquat<U, P> const & m);
-		template <typename U>
+		template<typename U>
 		GLM_FUNC_DECL tquat<T, P> & operator+=(tquat<U, P> const & q);
-		template <typename U>
+		template<typename U>
 		GLM_FUNC_DECL tquat<T, P> & operator-=(tquat<U, P> const & q);
-		template <typename U>
+		template<typename U>
 		GLM_FUNC_DECL tquat<T, P> & operator*=(tquat<U, P> const & q);
-		template <typename U>
+		template<typename U>
 		GLM_FUNC_DECL tquat<T, P> & operator*=(U s);
-		template <typename U>
+		template<typename U>
 		GLM_FUNC_DECL tquat<T, P> & operator/=(U s);
 	};
 
 	// -- Unary bit operators --
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_DECL tquat<T, P> operator+(tquat<T, P> const & q);
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_DECL tquat<T, P> operator-(tquat<T, P> const & q);
 
 	// -- Binary operators --
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_DECL tquat<T, P> operator+(tquat<T, P> const & q, tquat<T, P> const & p);
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_DECL tquat<T, P> operator*(tquat<T, P> const & q, tquat<T, P> const & p);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> operator*(tquat<T, P> const & q, tvec3<T, P> const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<3, T, P> operator*(tquat<T, P> const & q, vec<3, T, P> const & v);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> operator*(tvec3<T, P> const & v, tquat<T, P> const & q);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<3, T, P> operator*(vec<3, T, P> const & v, tquat<T, P> const & q);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec4<T, P> operator*(tquat<T, P> const & q, tvec4<T, P> const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<4, T, P> operator*(tquat<T, P> const & q, vec<4, T, P> const & v);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec4<T, P> operator*(tvec4<T, P> const & v, tquat<T, P> const & q);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<4, T, P> operator*(vec<4, T, P> const & v, tquat<T, P> const & q);
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_DECL tquat<T, P> operator*(tquat<T, P> const & q, T const & s);
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_DECL tquat<T, P> operator*(T const & s, tquat<T, P> const & q);
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_DECL tquat<T, P> operator/(tquat<T, P> const & q, T const & s);
 
 	// -- Boolean operators --
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_DECL bool operator==(tquat<T, P> const & q1, tquat<T, P> const & q2);
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_DECL bool operator!=(tquat<T, P> const & q1, tquat<T, P> const & q2);
 
 	/// Returns the length of the quaternion.
 	/// 
 	/// @see gtc_quaternion
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_DECL T length(tquat<T, P> const & q);
 
 	/// Returns the normalized quaternion.
 	/// 
 	/// @see gtc_quaternion
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_DECL tquat<T, P> normalize(tquat<T, P> const & q);
 		
 	/// Returns dot product of q1 and q2, i.e., q1[0] * q2[0] + q1[1] * q2[1] + ...
 	/// 
 	/// @see gtc_quaternion
-	template <typename T, precision P, template <typename, precision> class quatType>
-	GLM_FUNC_DECL T dot(quatType<T, P> const & x, quatType<T, P> const & y);
+	template<typename T, precision P>
+	GLM_FUNC_DECL T dot(tquat<T, P> const & x, tquat<T, P> const & y);
 
 	/// Spherical linear interpolation of two quaternions.
 	/// The interpolation is oriented and the rotation is performed at constant speed.
@@ -203,7 +203,7 @@ namespace glm
 	/// @tparam T Value type used to build the quaternion. Supported: half, float or double.
 	/// @see gtc_quaternion
 	/// @see - slerp(tquat<T, P> const & x, tquat<T, P> const & y, T const & a)
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_DECL tquat<T, P> mix(tquat<T, P> const & x, tquat<T, P> const & y, T a);
 
 	/// Linear interpolation of two quaternions.
@@ -214,7 +214,7 @@ namespace glm
 	/// @param a Interpolation factor. The interpolation is defined in the range [0, 1].
 	/// @tparam T Value type used to build the quaternion. Supported: half, float or double.
 	/// @see gtc_quaternion
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_DECL tquat<T, P> lerp(tquat<T, P> const & x, tquat<T, P> const & y, T a);
 
 	/// Spherical linear interpolation of two quaternions.
@@ -225,19 +225,19 @@ namespace glm
 	/// @param a Interpolation factor. The interpolation is defined beyond the range [0, 1].
 	/// @tparam T Value type used to build the quaternion. Supported: half, float or double.
 	/// @see gtc_quaternion
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_DECL tquat<T, P> slerp(tquat<T, P> const & x, tquat<T, P> const & y, T a);
 
 	/// Returns the q conjugate.
 	/// 
 	/// @see gtc_quaternion
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_DECL tquat<T, P> conjugate(tquat<T, P> const & q);
 
 	/// Returns the q inverse.
 	/// 
 	/// @see gtc_quaternion
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_DECL tquat<T, P> inverse(tquat<T, P> const & q);
 
 	/// Rotates a quaternion from a vector of 3 components axis and an angle.
@@ -247,69 +247,69 @@ namespace glm
 	/// @param axis Axis of the rotation
 	/// 
 	/// @see gtc_quaternion
-	template <typename T, precision P>
-	GLM_FUNC_DECL tquat<T, P> rotate(tquat<T, P> const & q, T const & angle, tvec3<T, P> const & axis);
+	template<typename T, precision P>
+	GLM_FUNC_DECL tquat<T, P> rotate(tquat<T, P> const & q, T const & angle, vec<3, T, P> const & axis);
 
 	/// Returns euler angles, pitch as x, yaw as y, roll as z.
 	/// The result is expressed in radians if GLM_FORCE_RADIANS is defined or degrees otherwise.
 	/// 
 	/// @see gtc_quaternion
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> eulerAngles(tquat<T, P> const & x);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<3, T, P> eulerAngles(tquat<T, P> const & x);
 
 	/// Returns roll value of euler angles expressed in radians.
 	///
 	/// @see gtx_quaternion
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_DECL T roll(tquat<T, P> const & x);
 
 	/// Returns pitch value of euler angles expressed in radians.
 	///
 	/// @see gtx_quaternion
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_DECL T pitch(tquat<T, P> const & x);
 
 	/// Returns yaw value of euler angles expressed in radians.
 	///
 	/// @see gtx_quaternion
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_DECL T yaw(tquat<T, P> const & x);
 
 	/// Converts a quaternion to a 3 * 3 matrix.
 	/// 
 	/// @see gtc_quaternion
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat3x3<T, P> mat3_cast(tquat<T, P> const & x);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<3, 3, T, P> mat3_cast(tquat<T, P> const & x);
 
 	/// Converts a quaternion to a 4 * 4 matrix.
 	/// 
 	/// @see gtc_quaternion
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat4x4<T, P> mat4_cast(tquat<T, P> const & x);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<4, 4, T, P> mat4_cast(tquat<T, P> const & x);
 
 	/// Converts a 3 * 3 matrix to a quaternion.
 	/// 
 	/// @see gtc_quaternion
-	template <typename T, precision P>
-	GLM_FUNC_DECL tquat<T, P> quat_cast(tmat3x3<T, P> const & x);
+	template<typename T, precision P>
+	GLM_FUNC_DECL tquat<T, P> quat_cast(mat<3, 3, T, P> const & x);
 
 	/// Converts a 4 * 4 matrix to a quaternion.
 	/// 
 	/// @see gtc_quaternion
-	template <typename T, precision P>
-	GLM_FUNC_DECL tquat<T, P> quat_cast(tmat4x4<T, P> const & x);
+	template<typename T, precision P>
+	GLM_FUNC_DECL tquat<T, P> quat_cast(mat<4, 4, T, P> const & x);
 
 	/// Returns the quaternion rotation angle.
 	///
 	/// @see gtc_quaternion
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_DECL T angle(tquat<T, P> const & x);
 
 	/// Returns the q rotation axis.
 	///
 	/// @see gtc_quaternion
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> axis(tquat<T, P> const & x);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<3, T, P> axis(tquat<T, P> const & x);
 
 	/// Build a quaternion from an angle and a normalized axis.
 	///
@@ -317,56 +317,56 @@ namespace glm
 	/// @param axis Axis of the quaternion, must be normalized.
 	///
 	/// @see gtc_quaternion
-	template <typename T, precision P>
-	GLM_FUNC_DECL tquat<T, P> angleAxis(T const & angle, tvec3<T, P> const & axis);
+	template<typename T, precision P>
+	GLM_FUNC_DECL tquat<T, P> angleAxis(T const & angle, vec<3, T, P> const & axis);
 
 	/// Returns the component-wise comparison result of x < y.
 	/// 
 	/// @tparam quatType Floating-point quaternion types.
 	///
 	/// @see gtc_quaternion
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec4<bool, P> lessThan(tquat<T, P> const & x, tquat<T, P> const & y);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<4, bool, P> lessThan(tquat<T, P> const & x, tquat<T, P> const & y);
 
 	/// Returns the component-wise comparison of result x <= y.
 	///
 	/// @tparam quatType Floating-point quaternion types.
 	///
 	/// @see gtc_quaternion
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec4<bool, P> lessThanEqual(tquat<T, P> const & x, tquat<T, P> const & y);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<4, bool, P> lessThanEqual(tquat<T, P> const & x, tquat<T, P> const & y);
 
 	/// Returns the component-wise comparison of result x > y.
 	///
 	/// @tparam quatType Floating-point quaternion types.
 	///
 	/// @see gtc_quaternion
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec4<bool, P> greaterThan(tquat<T, P> const & x, tquat<T, P> const & y);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<4, bool, P> greaterThan(tquat<T, P> const & x, tquat<T, P> const & y);
 
 	/// Returns the component-wise comparison of result x >= y.
 	///
 	/// @tparam quatType Floating-point quaternion types.
 	///
 	/// @see gtc_quaternion
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec4<bool, P> greaterThanEqual(tquat<T, P> const & x, tquat<T, P> const & y);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<4, bool, P> greaterThanEqual(tquat<T, P> const & x, tquat<T, P> const & y);
 
 	/// Returns the component-wise comparison of result x == y.
 	///
 	/// @tparam quatType Floating-point quaternion types.
 	///
 	/// @see gtc_quaternion
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec4<bool, P> equal(tquat<T, P> const & x, tquat<T, P> const & y);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<4, bool, P> equal(tquat<T, P> const & x, tquat<T, P> const & y);
 
 	/// Returns the component-wise comparison of result x != y.
 	/// 
 	/// @tparam quatType Floating-point quaternion types.
 	///
 	/// @see gtc_quaternion
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec4<bool, P> notEqual(tquat<T, P> const & x, tquat<T, P> const & y);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<4, bool, P> notEqual(tquat<T, P> const & x, tquat<T, P> const & y);
 
 	/// Returns true if x holds a NaN (not a number)
 	/// representation in the underlying implementation's set of
@@ -377,8 +377,8 @@ namespace glm
 	/// /!\ When using compiler fast math, this function may fail.
 	/// 
 	/// @tparam genType Floating-point scalar or vector types.
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec4<bool, P> isnan(tquat<T, P> const & x);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<4, bool, P> isnan(tquat<T, P> const & x);
 
 	/// Returns true if x holds a positive infinity or negative
 	/// infinity representation in the underlying implementation's
@@ -387,8 +387,8 @@ namespace glm
 	/// representations.
 	/// 
 	/// @tparam genType Floating-point scalar or vector types.
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec4<bool, P> isinf(tquat<T, P> const & x);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<4, bool, P> isinf(tquat<T, P> const & x);
 
 	/// @}
 } //namespace glm
diff --git a/glm/gtc/quaternion.inl b/glm/gtc/quaternion.inl
index c9b2af73..cb76abb7 100644
--- a/glm/gtc/quaternion.inl
+++ b/glm/gtc/quaternion.inl
@@ -9,17 +9,17 @@
 namespace glm{
 namespace detail
 {
-	template <typename T, precision P, bool Aligned>
-	struct compute_dot<tquat, T, P, Aligned>
+	template<typename T, precision P, bool Aligned>
+	struct compute_dot<tquat<T, P>, T, Aligned>
 	{
-		static GLM_FUNC_QUALIFIER T call(tquat<T, P> const& x, tquat<T, P> const& y)
+		static GLM_FUNC_QUALIFIER T call(tquat<T, P> const& a, tquat<T, P> const& b)
 		{
-			tvec4<T, P> tmp(x.x * y.x, x.y * y.y, x.z * y.z, x.w * y.w);
+			vec<4, T, P> tmp(a.x * b.x, a.y * b.y, a.z * b.z, a.w * b.w);
 			return (tmp.x + tmp.y) + (tmp.z + tmp.w);
 		}
 	};
 
-	template <typename T, precision P, bool Aligned>
+	template<typename T, precision P, bool Aligned>
 	struct compute_quat_add
 	{
 		static tquat<T, P> call(tquat<T, P> const& q, tquat<T, P> const& p)
@@ -28,7 +28,7 @@ namespace detail
 		}
 	};
 
-	template <typename T, precision P, bool Aligned>
+	template<typename T, precision P, bool Aligned>
 	struct compute_quat_sub
 	{
 		static tquat<T, P> call(tquat<T, P> const& q, tquat<T, P> const& p)
@@ -37,7 +37,7 @@ namespace detail
 		}
 	};
 
-	template <typename T, precision P, bool Aligned>
+	template<typename T, precision P, bool Aligned>
 	struct compute_quat_mul_scalar
 	{
 		static tquat<T, P> call(tquat<T, P> const& q, T s)
@@ -46,7 +46,7 @@ namespace detail
 		}
 	};
 
-	template <typename T, precision P, bool Aligned>
+	template<typename T, precision P, bool Aligned>
 	struct compute_quat_div_scalar
 	{
 		static tquat<T, P> call(tquat<T, P> const& q, T s)
@@ -55,26 +55,26 @@ namespace detail
 		}
 	};
 
-	template <typename T, precision P, bool Aligned>
+	template<typename T, precision P, bool Aligned>
 	struct compute_quat_mul_vec4
 	{
-		static tvec4<T, P> call(tquat<T, P> const & q, tvec4<T, P> const & v)
+		static vec<4, T, P> call(tquat<T, P> const & q, vec<4, T, P> const & v)
 		{
-			return tvec4<T, P>(q * tvec3<T, P>(v), v.w);
+			return vec<4, T, P>(q * vec<3, T, P>(v), v.w);
 		}
 	};
 }//namespace detail
 
 	// -- Component accesses --
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER T & tquat<T, P>::operator[](typename tquat<T, P>::length_type i)
 	{
 		assert(i >= 0 && i < this->length());
 		return (&x)[i];
 	}
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER T const & tquat<T, P>::operator[](typename tquat<T, P>::length_type i) const
 	{
 		assert(i >= 0 && i < this->length());
@@ -84,7 +84,7 @@ namespace detail
 	// -- Implicit basic constructors --
 
 #	if !GLM_HAS_DEFAULTED_FUNCTIONS || !defined(GLM_FORCE_NO_CTOR_INIT)
-		template <typename T, precision P>
+		template<typename T, precision P>
 		GLM_FUNC_QUALIFIER GLM_CONSTEXPR tquat<T, P>::tquat()
 #			ifndef GLM_FORCE_NO_CTOR_INIT
 				: x(0), y(0), z(0), w(1)
@@ -93,38 +93,38 @@ namespace detail
 #	endif
 
 #	if !GLM_HAS_DEFAULTED_FUNCTIONS
-		template <typename T, precision P>
+		template<typename T, precision P>
 		GLM_FUNC_QUALIFIER GLM_CONSTEXPR tquat<T, P>::tquat(tquat<T, P> const & q)
 			: x(q.x), y(q.y), z(q.z), w(q.w)
 		{}
 #	endif//!GLM_HAS_DEFAULTED_FUNCTIONS
 
-	template <typename T, precision P>
-	template <precision Q>
+	template<typename T, precision P>
+	template<precision Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tquat<T, P>::tquat(tquat<T, Q> const & q)
 		: x(q.x), y(q.y), z(q.z), w(q.w)
 	{}
 
 	// -- Explicit basic constructors --
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR tquat<T, P>::tquat(ctor)
 	{}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tquat<T, P>::tquat(T const & s, tvec3<T, P> const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tquat<T, P>::tquat(T const & s, vec<3, T, P> const & v)
 		: x(v.x), y(v.y), z(v.z), w(s)
 	{}
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tquat<T, P>::tquat(T const & w, T const & x, T const & y, T const & z)
 		: x(x), y(y), z(z), w(w)
 	{}
 
 	// -- Conversion constructors --
 
-	template <typename T, precision P>
-	template <typename U, precision Q>
+	template<typename T, precision P>
+	template<typename U, precision Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tquat<T, P>::tquat(tquat<U, Q> const & q)
 		: x(static_cast<T>(q.x))
 		, y(static_cast<T>(q.y))
@@ -132,7 +132,7 @@ namespace detail
 		, w(static_cast<T>(q.w))
 	{}
 
-	//template <typename valType> 
+	//template<typename valType> 
 	//GLM_FUNC_QUALIFIER tquat<valType>::tquat
 	//(
 	//	valType const & pitch,
@@ -140,9 +140,9 @@ namespace detail
 	//	valType const & roll
 	//)
 	//{
-	//	tvec3<valType> eulerAngle(pitch * valType(0.5), yaw * valType(0.5), roll * valType(0.5));
-	//	tvec3<valType> c = glm::cos(eulerAngle * valType(0.5));
-	//	tvec3<valType> s = glm::sin(eulerAngle * valType(0.5));
+	//	vec<3, valType> eulerAngle(pitch * valType(0.5), yaw * valType(0.5), roll * valType(0.5));
+	//	vec<3, valType> c = glm::cos(eulerAngle * valType(0.5));
+	//	vec<3, valType> s = glm::sin(eulerAngle * valType(0.5));
 	//	
 	//	this->w = c.x * c.y * c.z + s.x * s.y * s.z;
 	//	this->x = s.x * c.y * c.z - c.x * s.y * s.z;
@@ -150,21 +150,21 @@ namespace detail
 	//	this->z = c.x * c.y * s.z - s.x * s.y * c.z;
 	//}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tquat<T, P>::tquat(tvec3<T, P> const & u, tvec3<T, P> const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER tquat<T, P>::tquat(vec<3, T, P> const & u, vec<3, T, P> const & v)
 	{
-		tvec3<T, P> const LocalW(cross(u, v));
-		T Dot = detail::compute_dot<tvec3, T, P, detail::is_aligned<P>::value>::call(u, v);
+		vec<3, T, P> const LocalW(cross(u, v));
+		T Dot = detail::compute_dot<vec<3, T, P>, T, detail::is_aligned<P>::value>::call(u, v);
 		tquat<T, P> q(T(1) + Dot, LocalW.x, LocalW.y, LocalW.z);
 
 		*this = normalize(q);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tquat<T, P>::tquat(tvec3<T, P> const & eulerAngle)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER tquat<T, P>::tquat(vec<3, T, P> const & eulerAngle)
 	{
-		tvec3<T, P> c = glm::cos(eulerAngle * T(0.5));
-		tvec3<T, P> s = glm::sin(eulerAngle * T(0.5));
+		vec<3, T, P> c = glm::cos(eulerAngle * T(0.5));
+		vec<3, T, P> s = glm::sin(eulerAngle * T(0.5));
 		
 		this->w = c.x * c.y * c.z + s.x * s.y * s.z;
 		this->x = s.x * c.y * c.z - c.x * s.y * s.z;
@@ -172,39 +172,39 @@ namespace detail
 		this->z = c.x * c.y * s.z - s.x * s.y * c.z;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tquat<T, P>::tquat(tmat3x3<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER tquat<T, P>::tquat(mat<3, 3, T, P> const & m)
 	{
 		*this = quat_cast(m);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tquat<T, P>::tquat(tmat4x4<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER tquat<T, P>::tquat(mat<4, 4, T, P> const & m)
 	{
 		*this = quat_cast(m);
 	}
 
 #	if GLM_HAS_EXPLICIT_CONVERSION_OPERATORS
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tquat<T, P>::operator tmat3x3<T, P>()
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER tquat<T, P>::operator mat<3, 3, T, P>()
 	{
 		return mat3_cast(*this);
 	}
 	
-	template <typename T, precision P>	
-	GLM_FUNC_QUALIFIER tquat<T, P>::operator tmat4x4<T, P>()
+	template<typename T, precision P>	
+	GLM_FUNC_QUALIFIER tquat<T, P>::operator mat<4, 4, T, P>()
 	{
 		return mat4_cast(*this);
 	}
 #	endif//GLM_HAS_EXPLICIT_CONVERSION_OPERATORS
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER tquat<T, P> conjugate(tquat<T, P> const & q)
 	{
 		return tquat<T, P>(q.w, -q.x, -q.y, -q.z);
 	}
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER tquat<T, P> inverse(tquat<T, P> const & q)
 	{
 		return conjugate(q) / dot(q, q);
@@ -213,7 +213,7 @@ namespace detail
 	// -- Unary arithmetic operators --
 
 #	if !GLM_HAS_DEFAULTED_FUNCTIONS
-		template <typename T, precision P>
+		template<typename T, precision P>
 		GLM_FUNC_QUALIFIER tquat<T, P> & tquat<T, P>::operator=(tquat<T, P> const & q)
 		{
 			this->w = q.w;
@@ -224,8 +224,8 @@ namespace detail
 		}
 #	endif//!GLM_HAS_DEFAULTED_FUNCTIONS
 
-	template <typename T, precision P>
-	template <typename U>
+	template<typename T, precision P>
+	template<typename U>
 	GLM_FUNC_QUALIFIER tquat<T, P> & tquat<T, P>::operator=(tquat<U, P> const & q)
 	{
 		this->w = static_cast<T>(q.w);
@@ -235,22 +235,22 @@ namespace detail
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
+	template<typename T, precision P>
+	template<typename U>
 	GLM_FUNC_QUALIFIER tquat<T, P> & tquat<T, P>::operator+=(tquat<U, P> const& q)
 	{
 		return (*this = detail::compute_quat_add<T, P, detail::is_aligned<P>::value>::call(*this, tquat<T, P>(q)));
 	}
 
-	template <typename T, precision P>
-	template <typename U>
+	template<typename T, precision P>
+	template<typename U>
 	GLM_FUNC_QUALIFIER tquat<T, P> & tquat<T, P>::operator-=(tquat<U, P> const& q)
 	{
 		return (*this = detail::compute_quat_sub<T, P, detail::is_aligned<P>::value>::call(*this, tquat<T, P>(q)));
 	}
 
-	template <typename T, precision P>
-	template <typename U>
+	template<typename T, precision P>
+	template<typename U>
 	GLM_FUNC_QUALIFIER tquat<T, P> & tquat<T, P>::operator*=(tquat<U, P> const & r)
 	{
 		tquat<T, P> const p(*this);
@@ -263,15 +263,15 @@ namespace detail
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
+	template<typename T, precision P>
+	template<typename U>
 	GLM_FUNC_QUALIFIER tquat<T, P> & tquat<T, P>::operator*=(U s)
 	{
 		return (*this = detail::compute_quat_mul_scalar<T, P, detail::is_aligned<P>::value>::call(*this, static_cast<U>(s)));
 	}
 
-	template <typename T, precision P>
-	template <typename U>
+	template<typename T, precision P>
+	template<typename U>
 	GLM_FUNC_QUALIFIER tquat<T, P> & tquat<T, P>::operator/=(U s)
 	{
 		return (*this = detail::compute_quat_div_scalar<T, P, detail::is_aligned<P>::value>::call(*this, static_cast<U>(s)));
@@ -279,13 +279,13 @@ namespace detail
 
 	// -- Unary bit operators --
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER tquat<T, P> operator+(tquat<T, P> const & q)
 	{
 		return q;
 	}
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER tquat<T, P> operator-(tquat<T, P> const & q)
 	{
 		return tquat<T, P>(-q.w, -q.x, -q.y, -q.z);
@@ -293,60 +293,60 @@ namespace detail
 
 	// -- Binary operators --
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER tquat<T, P> operator+(tquat<T, P> const & q,	tquat<T, P> const & p)
 	{
 		return tquat<T, P>(q) += p;
 	}
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER tquat<T, P> operator*(tquat<T, P> const & q,	tquat<T, P> const & p)
 	{
 		return tquat<T, P>(q) *= p;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> operator*(tquat<T, P> const & q,	tvec3<T, P> const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> operator*(tquat<T, P> const & q,	vec<3, T, P> const & v)
 	{
-		tvec3<T, P> const QuatVector(q.x, q.y, q.z);
-		tvec3<T, P> const uv(glm::cross(QuatVector, v));
-		tvec3<T, P> const uuv(glm::cross(QuatVector, uv));
+		vec<3, T, P> const QuatVector(q.x, q.y, q.z);
+		vec<3, T, P> const uv(glm::cross(QuatVector, v));
+		vec<3, T, P> const uuv(glm::cross(QuatVector, uv));
 
 		return v + ((uv * q.w) + uuv) * static_cast<T>(2);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> operator*(tvec3<T, P> const & v, tquat<T, P> const & q)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> operator*(vec<3, T, P> const & v, tquat<T, P> const & q)
 	{
 		return glm::inverse(q) * v;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> operator*(tquat<T, P> const& q, tvec4<T, P> const& v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, T, P> operator*(tquat<T, P> const& q, vec<4, T, P> const& v)
 	{
 		return detail::compute_quat_mul_vec4<T, P, detail::is_aligned<P>::value>::call(q, v);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> operator*(tvec4<T, P> const & v, tquat<T, P> const & q)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, T, P> operator*(vec<4, T, P> const & v, tquat<T, P> const & q)
 	{
 		return glm::inverse(q) * v;
 	}
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER tquat<T, P> operator*(tquat<T, P> const & q, T const & s)
 	{
 		return tquat<T, P>(
 			q.w * s, q.x * s, q.y * s, q.z * s);
 	}
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER tquat<T, P> operator*(T const & s, tquat<T, P> const & q)
 	{
 		return q * s;
 	}
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER tquat<T, P> operator/(tquat<T, P> const & q, T const & s)
 	{
 		return tquat<T, P>(
@@ -355,13 +355,13 @@ namespace detail
 
 	// -- Boolean operators --
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER bool operator==(tquat<T, P> const & q1, tquat<T, P> const & q2)
 	{
 		return (q1.x == q2.x) && (q1.y == q2.y) && (q1.z == q2.z) && (q1.w == q2.w);
 	}
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER bool operator!=(tquat<T, P> const & q1, tquat<T, P> const & q2)
 	{
 		return (q1.x != q2.x) || (q1.y != q2.y) || (q1.z != q2.z) || (q1.w != q2.w);
@@ -369,13 +369,13 @@ namespace detail
 
 	// -- Operations --
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER T length(tquat<T, P> const & q)
 	{
 		return glm::sqrt(dot(q, q));
 	}
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER tquat<T, P> normalize(tquat<T, P> const & q)
 	{
 		T len = length(q);
@@ -385,7 +385,7 @@ namespace detail
 		return tquat<T, P>(q.w * oneOverLen, q.x * oneOverLen, q.y * oneOverLen, q.z * oneOverLen);
 	}
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER tquat<T, P> cross(tquat<T, P> const & q1, tquat<T, P> const & q2)
 	{
 		return tquat<T, P>(
@@ -396,7 +396,7 @@ namespace detail
 	}
 /*
 	// (x * sin(1 - a) * angle / sin(angle)) + (y * sin(a) * angle / sin(angle))
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER tquat<T, P> mix(tquat<T, P> const & x, tquat<T, P> const & y, T const & a)
 	{
 		if(a <= T(0)) return x;
@@ -433,7 +433,7 @@ namespace detail
 			k0 * x.z + k1 * y2.z);
 	}
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER tquat<T, P> mix2
 	(
 		tquat<T, P> const & x, 
@@ -471,7 +471,7 @@ namespace detail
 	}
 */
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER tquat<T, P> mix(tquat<T, P> const & x, tquat<T, P> const & y, T a)
 	{
 		T cosTheta = dot(x, y);
@@ -494,7 +494,7 @@ namespace detail
 		}
 	}
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER tquat<T, P> lerp(tquat<T, P> const & x, tquat<T, P> const & y, T a)
 	{
 		// Lerp is only defined in [0, 1]
@@ -504,7 +504,7 @@ namespace detail
 		return x * (T(1) - a) + (y * a);
 	}
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER tquat<T, P> slerp(tquat<T, P> const & x,	tquat<T, P> const & y, T a)
 	{
 		tquat<T, P> z = y;
@@ -537,10 +537,10 @@ namespace detail
 		}
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tquat<T, P> rotate(tquat<T, P> const & q, T const & angle, tvec3<T, P> const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER tquat<T, P> rotate(tquat<T, P> const & q, T const & angle, vec<3, T, P> const & v)
 	{
-		tvec3<T, P> Tmp = v;
+		vec<3, T, P> Tmp = v;
 
 		// Axis of rotation must be normalised
 		T len = glm::length(Tmp);
@@ -559,34 +559,34 @@ namespace detail
 		//return gtc::quaternion::cross(q, tquat<T, P>(cos(AngleRad * T(0.5)), Tmp.x * fSin, Tmp.y * fSin, Tmp.z * fSin));
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> eulerAngles(tquat<T, P> const & x)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> eulerAngles(tquat<T, P> const & x)
 	{
-		return tvec3<T, P>(pitch(x), yaw(x), roll(x));
+		return vec<3, T, P>(pitch(x), yaw(x), roll(x));
 	}
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER T roll(tquat<T, P> const & q)
 	{
 		return T(atan(T(2) * (q.x * q.y + q.w * q.z), q.w * q.w + q.x * q.x - q.y * q.y - q.z * q.z));
 	}
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER T pitch(tquat<T, P> const & q)
 	{
 		return T(atan(T(2) * (q.y * q.z + q.w * q.x), q.w * q.w - q.x * q.x - q.y * q.y + q.z * q.z));
 	}
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER T yaw(tquat<T, P> const & q)
 	{
 		return asin(clamp(T(-2) * (q.x * q.z - q.w * q.y), T(-1), T(1)));
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x3<T, P> mat3_cast(tquat<T, P> const & q)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, P> mat3_cast(tquat<T, P> const & q)
 	{
-		tmat3x3<T, P> Result(T(1));
+		mat<3, 3, T, P> Result(T(1));
 		T qxx(q.x * q.x);
 		T qyy(q.y * q.y);
 		T qzz(q.z * q.z);
@@ -611,14 +611,14 @@ namespace detail
 		return Result;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> mat4_cast(tquat<T, P> const & q)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, P> mat4_cast(tquat<T, P> const & q)
 	{
-		return tmat4x4<T, P>(mat3_cast(q));
+		return mat<4, 4, T, P>(mat3_cast(q));
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tquat<T, P> quat_cast(tmat3x3<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER tquat<T, P> quat_cast(mat<3, 3, T, P> const & m)
 	{
 		T fourXSquaredMinus1 = m[0][0] - m[1][1] - m[2][2];
 		T fourYSquaredMinus1 = m[1][1] - m[0][0] - m[2][2];
@@ -681,30 +681,30 @@ namespace detail
 		return Result;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tquat<T, P> quat_cast(tmat4x4<T, P> const & m4)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER tquat<T, P> quat_cast(mat<4, 4, T, P> const & m4)
 	{
-		return quat_cast(tmat3x3<T, P>(m4));
+		return quat_cast(mat<3, 3, T, P>(m4));
 	}
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER T angle(tquat<T, P> const & x)
 	{
 		return acos(x.w) * T(2);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> axis(tquat<T, P> const & x)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> axis(tquat<T, P> const & x)
 	{
 		T tmp1 = static_cast<T>(1) - x.w * x.w;
 		if(tmp1 <= static_cast<T>(0))
-			return tvec3<T, P>(0, 0, 1);
+			return vec<3, T, P>(0, 0, 1);
 		T tmp2 = static_cast<T>(1) / sqrt(tmp1);
-		return tvec3<T, P>(x.x * tmp2, x.y * tmp2, x.z * tmp2);
+		return vec<3, T, P>(x.x * tmp2, x.y * tmp2, x.z * tmp2);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tquat<T, P> angleAxis(T const & angle, tvec3<T, P> const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER tquat<T, P> angleAxis(T const & angle, vec<3, T, P> const & v)
 	{
 		tquat<T, P> Result(uninitialize);
 
@@ -718,74 +718,74 @@ namespace detail
 		return Result;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<bool, P> lessThan(tquat<T, P> const & x, tquat<T, P> const & y)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, bool, P> lessThan(tquat<T, P> const & x, tquat<T, P> const & y)
 	{
-		tvec4<bool, P> Result(uninitialize);
+		vec<4, bool, P> Result(uninitialize);
 		for(length_t i = 0; i < x.length(); ++i)
 			Result[i] = x[i] < y[i];
 		return Result;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<bool, P> lessThanEqual(tquat<T, P> const & x, tquat<T, P> const & y)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, bool, P> lessThanEqual(tquat<T, P> const & x, tquat<T, P> const & y)
 	{
-		tvec4<bool, P> Result(uninitialize);
+		vec<4, bool, P> Result(uninitialize);
 		for(length_t i = 0; i < x.length(); ++i)
 			Result[i] = x[i] <= y[i];
 		return Result;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<bool, P> greaterThan(tquat<T, P> const & x, tquat<T, P> const & y)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, bool, P> greaterThan(tquat<T, P> const & x, tquat<T, P> const & y)
 	{
-		tvec4<bool, P> Result(uninitialize);
+		vec<4, bool, P> Result(uninitialize);
 		for(length_t i = 0; i < x.length(); ++i)
 			Result[i] = x[i] > y[i];
 		return Result;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<bool, P> greaterThanEqual(tquat<T, P> const & x, tquat<T, P> const & y)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, bool, P> greaterThanEqual(tquat<T, P> const & x, tquat<T, P> const & y)
 	{
-		tvec4<bool, P> Result(uninitialize);
+		vec<4, bool, P> Result(uninitialize);
 		for(length_t i = 0; i < x.length(); ++i)
 			Result[i] = x[i] >= y[i];
 		return Result;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<bool, P> equal(tquat<T, P> const & x, tquat<T, P> const & y)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, bool, P> equal(tquat<T, P> const & x, tquat<T, P> const & y)
 	{
-		tvec4<bool, P> Result(uninitialize);
+		vec<4, bool, P> Result(uninitialize);
 		for(length_t i = 0; i < x.length(); ++i)
 			Result[i] = x[i] == y[i];
 		return Result;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<bool, P> notEqual(tquat<T, P> const & x, tquat<T, P> const & y)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, bool, P> notEqual(tquat<T, P> const & x, tquat<T, P> const & y)
 	{
-		tvec4<bool, P> Result(uninitialize);
+		vec<4, bool, P> Result(uninitialize);
 		for(length_t i = 0; i < x.length(); ++i)
 			Result[i] = x[i] != y[i];
 		return Result;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<bool, P> isnan(tquat<T, P> const& q)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, bool, P> isnan(tquat<T, P> const& q)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'isnan' only accept floating-point inputs");
 
-		return tvec4<bool, P>(isnan(q.x), isnan(q.y), isnan(q.z), isnan(q.w));
+		return vec<4, bool, P>(isnan(q.x), isnan(q.y), isnan(q.z), isnan(q.w));
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<bool, P> isinf(tquat<T, P> const& q)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, bool, P> isinf(tquat<T, P> const& q)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'isinf' only accept floating-point inputs");
 
-		return tvec4<bool, P>(isinf(q.x), isinf(q.y), isinf(q.z), isinf(q.w));
+		return vec<4, bool, P>(isinf(q.x), isinf(q.y), isinf(q.z), isinf(q.w));
 	}
 }//namespace glm
 
diff --git a/glm/gtc/quaternion_simd.inl b/glm/gtc/quaternion_simd.inl
index cca874bb..f0f22b5f 100644
--- a/glm/gtc/quaternion_simd.inl
+++ b/glm/gtc/quaternion_simd.inl
@@ -7,7 +7,7 @@ namespace glm{
 namespace detail
 {
 /*
-	template <precision P>
+	template<precision P>
 	struct compute_quat_mul<float, P, true>
 	{
 		static tquat<float, P> call(tquat<float, P> const& q1, tquat<float, P> const& q2)
@@ -61,8 +61,8 @@ namespace detail
 	};
 */
 
-	template <precision P>
-	struct compute_dot<tquat, float, P, true>
+	template<precision P>
+	struct compute_dot<tquat<float, P>, float, true>
 	{
 		static GLM_FUNC_QUALIFIER float call(tquat<float, P> const& x, tquat<float, P> const& y)
 		{
@@ -70,7 +70,7 @@ namespace detail
 		}
 	};
 
-	template <precision P>
+	template<precision P>
 	struct compute_quat_add<float, P, true>
 	{
 		static tquat<float, P> call(tquat<float, P> const& q, tquat<float, P> const& p)
@@ -82,7 +82,7 @@ namespace detail
 	};
 
 #	if GLM_ARCH & GLM_ARCH_AVX_BIT
-	template <precision P>
+	template<precision P>
 	struct compute_quat_add<double, P, true>
 	{
 		static tquat<double, P> call(tquat<double, P> const & a, tquat<double, P> const & b)
@@ -94,19 +94,19 @@ namespace detail
 	};
 #	endif
 
-	template <precision P>
+	template<precision P>
 	struct compute_quat_sub<float, P, true>
 	{
 		static tquat<float, P> call(tquat<float, P> const& q, tquat<float, P> const& p)
 		{
-			tvec4<float, P> Result(uninitialize);
+			vec<4, float, P> Result(uninitialize);
 			Result.data = _mm_sub_ps(q.data, p.data);
 			return Result;
 		}
 	};
 
 #	if GLM_ARCH & GLM_ARCH_AVX_BIT
-	template <precision P>
+	template<precision P>
 	struct compute_quat_sub<double, P, true>
 	{
 		static tquat<double, P> call(tquat<double, P> const & a, tquat<double, P> const & b)
@@ -118,19 +118,19 @@ namespace detail
 	};
 #	endif
 
-	template <precision P>
+	template<precision P>
 	struct compute_quat_mul_scalar<float, P, true>
 	{
 		static tquat<float, P> call(tquat<float, P> const& q, float s)
 		{
-			tvec4<float, P> Result(uninitialize);
+			vec<4, float, P> Result(uninitialize);
 			Result.data = _mm_mul_ps(q.data, _mm_set_ps1(s));
 			return Result;
 		}
 	};
 
 #	if GLM_ARCH & GLM_ARCH_AVX_BIT
-	template <precision P>
+	template<precision P>
 	struct compute_quat_mul_scalar<double, P, true>
 	{
 		static tquat<double, P> call(tquat<double, P> const& q, double s)
@@ -142,19 +142,19 @@ namespace detail
 	};
 #	endif
 
-	template <precision P>
+	template<precision P>
 	struct compute_quat_div_scalar<float, P, true>
 	{
 		static tquat<float, P> call(tquat<float, P> const& q, float s)
 		{
-			tvec4<float, P> Result(uninitialize);
+			vec<4, float, P> Result(uninitialize);
 			Result.data = _mm_div_ps(q.data, _mm_set_ps1(s));
 			return Result;
 		}
 	};
 
 #	if GLM_ARCH & GLM_ARCH_AVX_BIT
-	template <precision P>
+	template<precision P>
 	struct compute_quat_div_scalar<double, P, true>
 	{
 		static tquat<double, P> call(tquat<double, P> const& q, double s)
@@ -166,10 +166,10 @@ namespace detail
 	};
 #	endif
 
-	template <precision P>
+	template<precision P>
 	struct compute_quat_mul_vec4<float, P, true>
 	{
-		static tvec4<float, P> call(tquat<float, P> const& q, tvec4<float, P> const& v)
+		static vec<4, float, P> call(tquat<float, P> const& q, vec<4, float, P> const& v)
 		{
 			__m128 const q_wwww = _mm_shuffle_ps(q.data, q.data, _MM_SHUFFLE(3, 3, 3, 3));
 			__m128 const q_swp0 = _mm_shuffle_ps(q.data, q.data, _MM_SHUFFLE(3, 0, 2, 1));
@@ -186,7 +186,7 @@ namespace detail
 			uv  = _mm_mul_ps(uv, _mm_mul_ps(q_wwww, two));
 			uuv = _mm_mul_ps(uuv, two);
 
-			tvec4<float, P> Result(uninitialize);
+			vec<4, float, P> Result(uninitialize);
 			Result.data = _mm_add_ps(v.Data, _mm_add_ps(uv, uuv));
 			return Result;
 		}
diff --git a/glm/gtc/random.hpp b/glm/gtc/random.hpp
index 664fa9e7..f8d9f729 100644
--- a/glm/gtc/random.hpp
+++ b/glm/gtc/random.hpp
@@ -32,7 +32,7 @@ namespace glm
 	/// @param Max 
 	/// @tparam genType Value type. Currently supported: float or double scalars.
 	/// @see gtc_random
-	template <typename genTYpe>
+	template<typename genTYpe>
 	GLM_FUNC_DECL genTYpe linearRand(
 		genTYpe Min,
 		genTYpe Max);
@@ -44,17 +44,17 @@ namespace glm
 	/// @tparam T Value type. Currently supported: float or double.
 	/// @tparam vecType A vertor type: tvec1, tvec2, tvec3, tvec4 or compatible
 	/// @see gtc_random
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> linearRand(
-		vecType<T, P> const & Min,
-		vecType<T, P> const & Max);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, T, P> linearRand(
+		vecType<L, T, P> const& Min,
+		vecType<L, T, P> const& Max);
 
 	/// Generate random numbers in the interval [Min, Max], according a gaussian distribution 
 	/// 
 	/// @param Mean
 	/// @param Deviation
 	/// @see gtc_random
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL genType gaussRand(
 		genType Mean,
 		genType Deviation);
@@ -63,32 +63,32 @@ namespace glm
 	/// 
 	/// @param Radius 
 	/// @see gtc_random
-	template <typename T>
-	GLM_FUNC_DECL tvec2<T, defaultp> circularRand(
+	template<typename T>
+	GLM_FUNC_DECL vec<2, T, defaultp> circularRand(
 		T Radius);
 	
 	/// Generate a random 3D vector which coordinates are regulary distributed on a sphere of a given radius
 	/// 
 	/// @param Radius
 	/// @see gtc_random
-	template <typename T>
-	GLM_FUNC_DECL tvec3<T, defaultp> sphericalRand(
+	template<typename T>
+	GLM_FUNC_DECL vec<3, T, defaultp> sphericalRand(
 		T Radius);
 	
 	/// Generate a random 2D vector which coordinates are regulary distributed within the area of a disk of a given radius
 	/// 
 	/// @param Radius
 	/// @see gtc_random
-	template <typename T>
-	GLM_FUNC_DECL tvec2<T, defaultp> diskRand(
+	template<typename T>
+	GLM_FUNC_DECL vec<2, T, defaultp> diskRand(
 		T Radius);
 	
 	/// Generate a random 3D vector which coordinates are regulary distributed within the volume of a ball of a given radius
 	/// 
 	/// @param Radius
 	/// @see gtc_random
-	template <typename T>
-	GLM_FUNC_DECL tvec3<T, defaultp> ballRand(
+	template<typename T>
+	GLM_FUNC_DECL vec<3, T, defaultp> ballRand(
 		T Radius);
 	
 	/// @}
diff --git a/glm/gtc/random.inl b/glm/gtc/random.inl
index ad5926ee..834c485c 100644
--- a/glm/gtc/random.inl
+++ b/glm/gtc/random.inl
@@ -10,51 +10,51 @@
 namespace glm{
 namespace detail
 {
-	template <typename T, precision P, template <class, precision> class vecType>
+	template<length_t L, typename T, precision P, template<int, class, precision> class vecType>
 	struct compute_rand
 	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call();
+		GLM_FUNC_QUALIFIER static vecType<L, T, P> call();
 	};
 
-	template <precision P>
-	struct compute_rand<uint8, P, tvec1>
+	template<precision P>
+	struct compute_rand<1, uint8, P, vec>
 	{
-		GLM_FUNC_QUALIFIER static tvec1<uint8, P> call()
+		GLM_FUNC_QUALIFIER static vec<1, uint8, P> call()
 		{
-			return tvec1<uint8, P>(
+			return vec<1, uint8, P>(
 				std::rand() % std::numeric_limits<uint8>::max());
 		}
 	};
 
-	template <precision P>
-	struct compute_rand<uint8, P, tvec2>
+	template<precision P>
+	struct compute_rand<2, uint8, P, vec>
 	{
-		GLM_FUNC_QUALIFIER static tvec2<uint8, P> call()
+		GLM_FUNC_QUALIFIER static vec<2, uint8, P> call()
 		{
-			return tvec2<uint8, P>(
+			return vec<2, uint8, P>(
 				std::rand() % std::numeric_limits<uint8>::max(),
 				std::rand() % std::numeric_limits<uint8>::max());
 		}
 	};
 
-	template <precision P>
-	struct compute_rand<uint8, P, tvec3>
+	template<precision P>
+	struct compute_rand<3, uint8, P, vec>
 	{
-		GLM_FUNC_QUALIFIER static tvec3<uint8, P> call()
+		GLM_FUNC_QUALIFIER static vec<3, uint8, P> call()
 		{
-			return tvec3<uint8, P>(
+			return vec<3, uint8, P>(
 				std::rand() % std::numeric_limits<uint8>::max(),
 				std::rand() % std::numeric_limits<uint8>::max(),
 				std::rand() % std::numeric_limits<uint8>::max());
 		}
 	};
 
-	template <precision P>
-	struct compute_rand<uint8, P, tvec4>
+	template<precision P>
+	struct compute_rand<4, uint8, P, vec>
 	{
-		GLM_FUNC_QUALIFIER static tvec4<uint8, P> call()
+		GLM_FUNC_QUALIFIER static vec<4, uint8, P> call()
 		{
-			return tvec4<uint8, P>(
+			return vec<4, uint8, P>(
 				std::rand() % std::numeric_limits<uint8>::max(),
 				std::rand() % std::numeric_limits<uint8>::max(),
 				std::rand() % std::numeric_limits<uint8>::max(),
@@ -62,214 +62,214 @@ namespace detail
 		}
 	};
 
-	template <precision P, template <class, precision> class vecType>
-	struct compute_rand<uint16, P, vecType>
+	template<length_t L, precision P, template<length_t, typename, precision> class vecType>
+	struct compute_rand<L, uint16, P, vecType>
 	{
-		GLM_FUNC_QUALIFIER static vecType<uint16, P> call()
+		GLM_FUNC_QUALIFIER static vecType<L, uint16, P> call()
 		{
 			return
-				(vecType<uint16, P>(compute_rand<uint8, P, vecType>::call()) << static_cast<uint16>(8)) |
-				(vecType<uint16, P>(compute_rand<uint8, P, vecType>::call()) << static_cast<uint16>(0));
+				(vecType<L, uint16, P>(compute_rand<L, uint8, P, vecType>::call()) << static_cast<uint16>(8)) |
+				(vecType<L, uint16, P>(compute_rand<L, uint8, P, vecType>::call()) << static_cast<uint16>(0));
 		}
 	};
 
-	template <precision P, template <class, precision> class vecType>
-	struct compute_rand<uint32, P, vecType>
+	template<length_t L, precision P, template<length_t, typename, precision> class vecType>
+	struct compute_rand<L, uint32, P, vecType>
 	{
-		GLM_FUNC_QUALIFIER static vecType<uint32, P> call()
+		GLM_FUNC_QUALIFIER static vecType<L, uint32, P> call()
 		{
 			return
-				(vecType<uint32, P>(compute_rand<uint16, P, vecType>::call()) << static_cast<uint32>(16)) |
-				(vecType<uint32, P>(compute_rand<uint16, P, vecType>::call()) << static_cast<uint32>(0));
+				(vecType<L, uint32, P>(compute_rand<L, uint16, P, vecType>::call()) << static_cast<uint32>(16)) |
+				(vecType<L, uint32, P>(compute_rand<L, uint16, P, vecType>::call()) << static_cast<uint32>(0));
 		}
 	};
 
-	template <precision P, template <class, precision> class vecType>
-	struct compute_rand<uint64, P, vecType>
+	template<length_t L, precision P, template<length_t, typename, precision> class vecType>
+	struct compute_rand<L, uint64, P, vecType>
 	{
-		GLM_FUNC_QUALIFIER static vecType<uint64, P> call()
+		GLM_FUNC_QUALIFIER static vecType<L, uint64, P> call()
 		{
 			return
-				(vecType<uint64, P>(compute_rand<uint32, P, vecType>::call()) << static_cast<uint64>(32)) |
-				(vecType<uint64, P>(compute_rand<uint32, P, vecType>::call()) << static_cast<uint64>(0));
+				(vecType<L, uint64, P>(compute_rand<L, uint32, P, vecType>::call()) << static_cast<uint64>(32)) |
+				(vecType<L, uint64, P>(compute_rand<L, uint32, P, vecType>::call()) << static_cast<uint64>(0));
 		}
 	};
 
-	template <typename T, precision P, template <class, precision> class vecType>
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
 	struct compute_linearRand
 	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & Min, vecType<T, P> const & Max);
+		GLM_FUNC_QUALIFIER static vecType<L, T, P> call(vecType<L, T, P> const & Min, vecType<L, T, P> const & Max);
 	};
 
-	template <precision P, template <class, precision> class vecType>
-	struct compute_linearRand<int8, P, vecType>
+	template<length_t L, precision P, template<length_t, typename, precision> class vecType>
+	struct compute_linearRand<L, int8, P, vecType>
 	{
-		GLM_FUNC_QUALIFIER static vecType<int8, P> call(vecType<int8, P> const & Min, vecType<int8, P> const & Max)
+		GLM_FUNC_QUALIFIER static vecType<L, int8, P> call(vecType<L, int8, P> const & Min, vecType<L, int8, P> const & Max)
 		{
-			return (vecType<int8, P>(compute_rand<uint8, P, vecType>::call() % vecType<uint8, P>(Max + static_cast<int8>(1) - Min))) + Min;
+			return (vecType<L, int8, P>(compute_rand<L, uint8, P, vecType>::call() % vecType<L, uint8, P>(Max + static_cast<int8>(1) - Min))) + Min;
 		}
 	};
 
-	template <precision P, template <class, precision> class vecType>
-	struct compute_linearRand<uint8, P, vecType>
+	template<length_t L, precision P, template<length_t, typename, precision> class vecType>
+	struct compute_linearRand<L, uint8, P, vecType>
 	{
-		GLM_FUNC_QUALIFIER static vecType<uint8, P> call(vecType<uint8, P> const & Min, vecType<uint8, P> const & Max)
+		GLM_FUNC_QUALIFIER static vecType<L, uint8, P> call(vecType<L, uint8, P> const & Min, vecType<L, uint8, P> const & Max)
 		{
-			return (compute_rand<uint8, P, vecType>::call() % (Max + static_cast<uint8>(1) - Min)) + Min;
+			return (compute_rand<L, uint8, P, vecType>::call() % (Max + static_cast<uint8>(1) - Min)) + Min;
 		}
 	};
 
-	template <precision P, template <class, precision> class vecType>
-	struct compute_linearRand<int16, P, vecType>
+	template<length_t L, precision P, template<length_t, typename, precision> class vecType>
+	struct compute_linearRand<L, int16, P, vecType>
 	{
-		GLM_FUNC_QUALIFIER static vecType<int16, P> call(vecType<int16, P> const & Min, vecType<int16, P> const & Max)
+		GLM_FUNC_QUALIFIER static vecType<L, int16, P> call(vecType<L, int16, P> const & Min, vecType<L, int16, P> const & Max)
 		{
-			return (vecType<int16, P>(compute_rand<uint16, P, vecType>::call() % vecType<uint16, P>(Max + static_cast<int16>(1) - Min))) + Min;
+			return (vecType<L, int16, P>(compute_rand<L, uint16, P, vecType>::call() % vecType<L, uint16, P>(Max + static_cast<int16>(1) - Min))) + Min;
 		}
 	};
 
-	template <precision P, template <class, precision> class vecType>
-	struct compute_linearRand<uint16, P, vecType>
+	template<length_t L, precision P, template<length_t, typename, precision> class vecType>
+	struct compute_linearRand<L, uint16, P, vecType>
 	{
-		GLM_FUNC_QUALIFIER static vecType<uint16, P> call(vecType<uint16, P> const & Min, vecType<uint16, P> const & Max)
+		GLM_FUNC_QUALIFIER static vecType<L, uint16, P> call(vecType<L, uint16, P> const & Min, vecType<L, uint16, P> const & Max)
 		{
-			return (compute_rand<uint16, P, vecType>::call() % (Max + static_cast<uint16>(1) - Min)) + Min;
+			return (compute_rand<L, uint16, P, vecType>::call() % (Max + static_cast<uint16>(1) - Min)) + Min;
 		}
 	};
 
-	template <precision P, template <class, precision> class vecType>
-	struct compute_linearRand<int32, P, vecType>
+	template<length_t L, precision P, template<length_t, typename, precision> class vecType>
+	struct compute_linearRand<L, int32, P, vecType>
 	{
-		GLM_FUNC_QUALIFIER static vecType<int32, P> call(vecType<int32, P> const & Min, vecType<int32, P> const & Max)
+		GLM_FUNC_QUALIFIER static vecType<L, int32, P> call(vecType<L, int32, P> const & Min, vecType<L, int32, P> const & Max)
 		{
-			return (vecType<int32, P>(compute_rand<uint32, P, vecType>::call() % vecType<uint32, P>(Max + static_cast<int32>(1) - Min))) + Min;
+			return (vecType<L, int32, P>(compute_rand<L, uint32, P, vecType>::call() % vecType<L, uint32, P>(Max + static_cast<int32>(1) - Min))) + Min;
 		}
 	};
 
-	template <precision P, template <class, precision> class vecType>
-	struct compute_linearRand<uint32, P, vecType>
+	template<length_t L, precision P, template<length_t, typename, precision> class vecType>
+	struct compute_linearRand<L, uint32, P, vecType>
 	{
-		GLM_FUNC_QUALIFIER static vecType<uint32, P> call(vecType<uint32, P> const & Min, vecType<uint32, P> const & Max)
+		GLM_FUNC_QUALIFIER static vecType<L, uint32, P> call(vecType<L, uint32, P> const & Min, vecType<L, uint32, P> const & Max)
 		{
-			return (compute_rand<uint32, P, vecType>::call() % (Max + static_cast<uint32>(1) - Min)) + Min;
+			return (compute_rand<L, uint32, P, vecType>::call() % (Max + static_cast<uint32>(1) - Min)) + Min;
 		}
 	};
  
-	template <precision P, template <class, precision> class vecType>
-	struct compute_linearRand<int64, P, vecType>
+	template<length_t L, precision P, template<length_t, typename, precision> class vecType>
+	struct compute_linearRand<L, int64, P, vecType>
 	{
-		GLM_FUNC_QUALIFIER static vecType<int64, P> call(vecType<int64, P> const & Min, vecType<int64, P> const & Max)
+		GLM_FUNC_QUALIFIER static vecType<L, int64, P> call(vecType<L, int64, P> const & Min, vecType<L, int64, P> const & Max)
 		{
-			return (vecType<int64, P>(compute_rand<uint64, P, vecType>::call() % vecType<uint64, P>(Max + static_cast<int64>(1) - Min))) + Min;
+			return (vecType<L, int64, P>(compute_rand<L, uint64, P, vecType>::call() % vecType<L, uint64, P>(Max + static_cast<int64>(1) - Min))) + Min;
 		}
 	};
 
-	template <precision P, template <class, precision> class vecType>
-	struct compute_linearRand<uint64, P, vecType>
+	template<length_t L, precision P, template<length_t, typename, precision> class vecType>
+	struct compute_linearRand<L, uint64, P, vecType>
 	{
-		GLM_FUNC_QUALIFIER static vecType<uint64, P> call(vecType<uint64, P> const & Min, vecType<uint64, P> const & Max)
+		GLM_FUNC_QUALIFIER static vecType<L, uint64, P> call(vecType<L, uint64, P> const & Min, vecType<L, uint64, P> const & Max)
 		{
-			return (compute_rand<uint64, P, vecType>::call() % (Max + static_cast<uint64>(1) - Min)) + Min;
+			return (compute_rand<L, uint64, P, vecType>::call() % (Max + static_cast<uint64>(1) - Min)) + Min;
 		}
 	};
 
-	template <template <class, precision> class vecType>
-	struct compute_linearRand<float, lowp, vecType>
+	template<length_t L, template<length_t, typename, precision> class vecType>
+	struct compute_linearRand<L, float, lowp, vecType>
 	{
-		GLM_FUNC_QUALIFIER static vecType<float, lowp> call(vecType<float, lowp> const & Min, vecType<float, lowp> const & Max)
+		GLM_FUNC_QUALIFIER static vecType<L, float, lowp> call(vecType<L, float, lowp> const & Min, vecType<L, float, lowp> const & Max)
 		{
-			return vecType<float, lowp>(compute_rand<uint8, lowp, vecType>::call()) / static_cast<float>(std::numeric_limits<uint8>::max()) * (Max - Min) + Min;
+			return vecType<L, float, lowp>(compute_rand<L, uint8, lowp, vecType>::call()) / static_cast<float>(std::numeric_limits<uint8>::max()) * (Max - Min) + Min;
 		}
 	};
 
-	template <template <class, precision> class vecType>
-	struct compute_linearRand<float, mediump, vecType>
+	template<length_t L, template<length_t, typename, precision> class vecType>
+	struct compute_linearRand<L, float, mediump, vecType>
 	{
-		GLM_FUNC_QUALIFIER static vecType<float, mediump> call(vecType<float, mediump> const & Min, vecType<float, mediump> const & Max)
+		GLM_FUNC_QUALIFIER static vecType<L, float, mediump> call(vecType<L, float, mediump> const & Min, vecType<L, float, mediump> const & Max)
 		{
-			return vecType<float, mediump>(compute_rand<uint16, mediump, vecType>::call()) / static_cast<float>(std::numeric_limits<uint16>::max()) * (Max - Min) + Min;
+			return vecType<L, float, mediump>(compute_rand<L, uint16, mediump, vecType>::call()) / static_cast<float>(std::numeric_limits<uint16>::max()) * (Max - Min) + Min;
 		}
 	};
 
-	template <template <class, precision> class vecType>
-	struct compute_linearRand<float, highp, vecType>
+	template<length_t L, template<length_t, typename, precision> class vecType>
+	struct compute_linearRand<L, float, highp, vecType>
 	{
-		GLM_FUNC_QUALIFIER static vecType<float, highp> call(vecType<float, highp> const & Min, vecType<float, highp> const & Max)
+		GLM_FUNC_QUALIFIER static vecType<L, float, highp> call(vecType<L, float, highp> const & Min, vecType<L, float, highp> const & Max)
 		{
-			return vecType<float, highp>(compute_rand<uint32, highp, vecType>::call()) / static_cast<float>(std::numeric_limits<uint32>::max()) * (Max - Min) + Min;
+			return vecType<L, float, highp>(compute_rand<L, uint32, highp, vecType>::call()) / static_cast<float>(std::numeric_limits<uint32>::max()) * (Max - Min) + Min;
 		}
 	};
 
-	template <template <class, precision> class vecType>
-	struct compute_linearRand<double, lowp, vecType>
+	template<length_t L, template<length_t, typename, precision> class vecType>
+	struct compute_linearRand<L, double, lowp, vecType>
 	{
-		GLM_FUNC_QUALIFIER static vecType<double, lowp> call(vecType<double, lowp> const & Min, vecType<double, lowp> const & Max)
+		GLM_FUNC_QUALIFIER static vecType<L, double, lowp> call(vecType<L, double, lowp> const & Min, vecType<L, double, lowp> const & Max)
 		{
-			return vecType<double, lowp>(compute_rand<uint16, lowp, vecType>::call()) / static_cast<double>(std::numeric_limits<uint16>::max()) * (Max - Min) + Min;
+			return vecType<L, double, lowp>(compute_rand<L, uint16, lowp, vecType>::call()) / static_cast<double>(std::numeric_limits<uint16>::max()) * (Max - Min) + Min;
 		}
 	};
 
-	template <template <class, precision> class vecType>
-	struct compute_linearRand<double, mediump, vecType>
+	template<length_t L, template<length_t, typename, precision> class vecType>
+	struct compute_linearRand<L, double, mediump, vecType>
 	{
-		GLM_FUNC_QUALIFIER static vecType<double, mediump> call(vecType<double, mediump> const & Min, vecType<double, mediump> const & Max)
+		GLM_FUNC_QUALIFIER static vecType<L, double, mediump> call(vecType<L, double, mediump> const & Min, vecType<L, double, mediump> const & Max)
 		{
-			return vecType<double, mediump>(compute_rand<uint32, mediump, vecType>::call()) / static_cast<double>(std::numeric_limits<uint32>::max()) * (Max - Min) + Min;
+			return vecType<L, double, mediump>(compute_rand<L, uint32, mediump, vecType>::call()) / static_cast<double>(std::numeric_limits<uint32>::max()) * (Max - Min) + Min;
 		}
 	};
 
-	template <template <class, precision> class vecType>
-	struct compute_linearRand<double, highp, vecType>
+	template<length_t L, template<length_t, typename, precision> class vecType>
+	struct compute_linearRand<L, double, highp, vecType>
 	{
-		GLM_FUNC_QUALIFIER static vecType<double, highp> call(vecType<double, highp> const & Min, vecType<double, highp> const & Max)
+		GLM_FUNC_QUALIFIER static vecType<L, double, highp> call(vecType<L, double, highp> const & Min, vecType<L, double, highp> const & Max)
 		{
-			return vecType<double, highp>(compute_rand<uint64, highp, vecType>::call()) / static_cast<double>(std::numeric_limits<uint64>::max()) * (Max - Min) + Min;
+			return vecType<L, double, highp>(compute_rand<L, uint64, highp, vecType>::call()) / static_cast<double>(std::numeric_limits<uint64>::max()) * (Max - Min) + Min;
 		}
 	};
 
-	template <template <class, precision> class vecType>
-	struct compute_linearRand<long double, lowp, vecType>
+	template<length_t L, template<length_t, typename, precision> class vecType>
+	struct compute_linearRand<L, long double, lowp, vecType>
 	{
-		GLM_FUNC_QUALIFIER static vecType<long double, lowp> call(vecType<long double, lowp> const & Min, vecType<long double, lowp> const & Max)
+		GLM_FUNC_QUALIFIER static vecType<L, long double, lowp> call(vecType<L, long double, lowp> const & Min, vecType<L, long double, lowp> const & Max)
 		{
-			return vecType<long double, lowp>(compute_rand<uint32, lowp, vecType>::call()) / static_cast<long double>(std::numeric_limits<uint32>::max()) * (Max - Min) + Min;
+			return vecType<L, long double, lowp>(compute_rand<L, uint32, lowp, vecType>::call()) / static_cast<long double>(std::numeric_limits<uint32>::max()) * (Max - Min) + Min;
 		}
 	};
 
-	template <template <class, precision> class vecType>
-	struct compute_linearRand<long double, mediump, vecType>
+	template<length_t L, template<length_t, typename, precision> class vecType>
+	struct compute_linearRand<L, long double, mediump, vecType>
 	{
-		GLM_FUNC_QUALIFIER static vecType<long double, mediump> call(vecType<long double, mediump> const & Min, vecType<long double, mediump> const & Max)
+		GLM_FUNC_QUALIFIER static vecType<L, long double, mediump> call(vecType<L, long double, mediump> const & Min, vecType<L, long double, mediump> const & Max)
 		{
-			return vecType<long double, mediump>(compute_rand<uint64, mediump, vecType>::call()) / static_cast<long double>(std::numeric_limits<uint64>::max()) * (Max - Min) + Min;
+			return vecType<L, long double, mediump>(compute_rand<L, uint64, mediump, vecType>::call()) / static_cast<long double>(std::numeric_limits<uint64>::max()) * (Max - Min) + Min;
 		}
 	};
 
-	template <template <class, precision> class vecType>
-	struct compute_linearRand<long double, highp, vecType>
+	template<length_t L, template<length_t, typename, precision> class vecType>
+	struct compute_linearRand<L, long double, highp, vecType>
 	{
-		GLM_FUNC_QUALIFIER static vecType<long double, highp> call(vecType<long double, highp> const & Min, vecType<long double, highp> const & Max)
+		GLM_FUNC_QUALIFIER static vecType<L, long double, highp> call(vecType<L, long double, highp> const & Min, vecType<L, long double, highp> const & Max)
 		{
-			return vecType<long double, highp>(compute_rand<uint64, highp, vecType>::call()) / static_cast<long double>(std::numeric_limits<uint64>::max()) * (Max - Min) + Min;
+			return vecType<L, long double, highp>(compute_rand<L, uint64, highp, vecType>::call()) / static_cast<long double>(std::numeric_limits<uint64>::max()) * (Max - Min) + Min;
 		}
 	};
 }//namespace detail
 
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER genType linearRand(genType Min, genType Max)
 	{
-		return detail::compute_linearRand<genType, highp, tvec1>::call(
-			tvec1<genType, highp>(Min),
-			tvec1<genType, highp>(Max)).x;
+		return detail::compute_linearRand<1, genType, highp, vec>::call(
+			vec<1, genType, highp>(Min),
+			vec<1, genType, highp>(Max)).x;
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> linearRand(vecType<T, P> const & Min, vecType<T, P> const & Max)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> linearRand(vecType<L, T, P> const & Min, vecType<L, T, P> const & Max)
 	{
-		return detail::compute_linearRand<T, P, vecType>::call(Min, Max);
+		return detail::compute_linearRand<L, T, P, vecType>::call(Min, Max);
 	}
 
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER genType gaussRand(genType Mean, genType Deviation)
 	{
 		genType w, x1, x2;
@@ -285,23 +285,23 @@ namespace detail
 		return x2 * Deviation * Deviation * sqrt((genType(-2) * log(w)) / w) + Mean;
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> gaussRand(vecType<T, P> const & Mean, vecType<T, P> const & Deviation)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> gaussRand(vecType<L, T, P> const & Mean, vecType<L, T, P> const & Deviation)
 	{
-		return detail::functor2<T, P, vecType>::call(gaussRand, Mean, Deviation);
+		return detail::functor2<L, T, P>::call(gaussRand, Mean, Deviation);
 	}
 
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec2<T, defaultp> diskRand(T Radius)
+	template<typename T>
+	GLM_FUNC_QUALIFIER vec<2, T, defaultp> diskRand(T Radius)
 	{		
-		tvec2<T, defaultp> Result(T(0));
+		vec<2, T, defaultp> Result(T(0));
 		T LenRadius(T(0));
 		
 		do
 		{
 			Result = linearRand(
-				tvec2<T, defaultp>(-Radius),
-				tvec2<T, defaultp>(Radius));
+				vec<2, T, defaultp>(-Radius),
+				vec<2, T, defaultp>(Radius));
 			LenRadius = length(Result);
 		}
 		while(LenRadius > Radius);
@@ -309,17 +309,17 @@ namespace detail
 		return Result;
 	}
 	
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec3<T, defaultp> ballRand(T Radius)
+	template<typename T>
+	GLM_FUNC_QUALIFIER vec<3, T, defaultp> ballRand(T Radius)
 	{		
-		tvec3<T, defaultp> Result(T(0));
+		vec<3, T, defaultp> Result(T(0));
 		T LenRadius(T(0));
 		
 		do
 		{
 			Result = linearRand(
-				tvec3<T, defaultp>(-Radius),
-				tvec3<T, defaultp>(Radius));
+				vec<3, T, defaultp>(-Radius),
+				vec<3, T, defaultp>(Radius));
 			LenRadius = length(Result);
 		}
 		while(LenRadius > Radius);
@@ -327,15 +327,15 @@ namespace detail
 		return Result;
 	}
 	
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec2<T, defaultp> circularRand(T Radius)
+	template<typename T>
+	GLM_FUNC_QUALIFIER vec<2, T, defaultp> circularRand(T Radius)
 	{
 		T a = linearRand(T(0), T(6.283185307179586476925286766559f));
-		return tvec2<T, defaultp>(cos(a), sin(a)) * Radius;		
+		return vec<2, T, defaultp>(cos(a), sin(a)) * Radius;		
 	}
 	
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec3<T, defaultp> sphericalRand(T Radius)
+	template<typename T>
+	GLM_FUNC_QUALIFIER vec<3, T, defaultp> sphericalRand(T Radius)
 	{
 		T z = linearRand(T(-1), T(1));
 		T a = linearRand(T(0), T(6.283185307179586476925286766559f));
@@ -345,6 +345,6 @@ namespace detail
 		T x = r * cos(a);
 		T y = r * sin(a);
 	
-		return tvec3<T, defaultp>(x, y, z) * Radius;	
+		return vec<3, T, defaultp>(x, y, z) * Radius;	
 	}
 }//namespace glm
diff --git a/glm/gtc/reciprocal.hpp b/glm/gtc/reciprocal.hpp
index c14a4fec..6b09e06b 100644
--- a/glm/gtc/reciprocal.hpp
+++ b/glm/gtc/reciprocal.hpp
@@ -30,7 +30,7 @@ namespace glm
 	/// @tparam genType Floating-point scalar or vector types.
 	/// 
 	/// @see gtc_reciprocal
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL genType sec(genType angle);
 
 	/// Cosecant function.
@@ -39,7 +39,7 @@ namespace glm
 	/// @tparam genType Floating-point scalar or vector types.
 	/// 
 	/// @see gtc_reciprocal
-	template <typename genType> 
+	template<typename genType> 
 	GLM_FUNC_DECL genType csc(genType angle);
 		
 	/// Cotangent function.
@@ -48,7 +48,7 @@ namespace glm
 	/// @tparam genType Floating-point scalar or vector types.
 	/// 
 	/// @see gtc_reciprocal
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL genType cot(genType angle);
 
 	/// Inverse secant function.
@@ -57,7 +57,7 @@ namespace glm
 	/// @tparam genType Floating-point scalar or vector types.
 	/// 
 	/// @see gtc_reciprocal
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL genType asec(genType x);
 
 	/// Inverse cosecant function.
@@ -66,7 +66,7 @@ namespace glm
 	/// @tparam genType Floating-point scalar or vector types.
 	/// 
 	/// @see gtc_reciprocal
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL genType acsc(genType x);
 		
 	/// Inverse cotangent function.
@@ -75,7 +75,7 @@ namespace glm
 	/// @tparam genType Floating-point scalar or vector types.
 	/// 
 	/// @see gtc_reciprocal
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL genType acot(genType x);
 
 	/// Secant hyperbolic function.
@@ -83,7 +83,7 @@ namespace glm
 	/// @tparam genType Floating-point scalar or vector types.
 	/// 
 	/// @see gtc_reciprocal
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL genType sech(genType angle);
 
 	/// Cosecant hyperbolic function.
@@ -91,7 +91,7 @@ namespace glm
 	/// @tparam genType Floating-point scalar or vector types.
 	/// 
 	/// @see gtc_reciprocal
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL genType csch(genType angle);
 		
 	/// Cotangent hyperbolic function.
@@ -99,7 +99,7 @@ namespace glm
 	/// @tparam genType Floating-point scalar or vector types.
 	/// 
 	/// @see gtc_reciprocal
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL genType coth(genType angle);
 
 	/// Inverse secant hyperbolic function.
@@ -108,7 +108,7 @@ namespace glm
 	/// @tparam genType Floating-point scalar or vector types.
 	/// 
 	/// @see gtc_reciprocal
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL genType asech(genType x);
 
 	/// Inverse cosecant hyperbolic function.
@@ -117,7 +117,7 @@ namespace glm
 	/// @tparam genType Floating-point scalar or vector types.
 	/// 
 	/// @see gtc_reciprocal
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL genType acsch(genType x);
 		
 	/// Inverse cotangent hyperbolic function.
@@ -126,7 +126,7 @@ namespace glm
 	/// @tparam genType Floating-point scalar or vector types.
 	/// 
 	/// @see gtc_reciprocal
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL genType acoth(genType x);
 
 	/// @}
diff --git a/glm/gtc/reciprocal.inl b/glm/gtc/reciprocal.inl
index c625ac90..1c667ad3 100644
--- a/glm/gtc/reciprocal.inl
+++ b/glm/gtc/reciprocal.inl
@@ -7,37 +7,37 @@
 namespace glm
 {
 	// sec
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER genType sec(genType angle)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'sec' only accept floating-point values");
 		return genType(1) / glm::cos(angle);
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> sec(vecType<T, P> const & x)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> sec(vecType<L, T, P> const & x)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'sec' only accept floating-point inputs");
-		return detail::functor1<T, T, P, vecType>::call(sec, x);
+		return detail::functor1<L, T, T, P>::call(sec, x);
 	}
 
 	// csc
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER genType csc(genType angle)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'csc' only accept floating-point values");
 		return genType(1) / glm::sin(angle);
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> csc(vecType<T, P> const & x)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> csc(vecType<L, T, P> const & x)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'csc' only accept floating-point inputs");
-		return detail::functor1<T, T, P, vecType>::call(csc, x);
+		return detail::functor1<L, T, T, P>::call(csc, x);
 	}
 
 	// cot
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER genType cot(genType angle)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'cot' only accept floating-point values");
@@ -46,45 +46,45 @@ namespace glm
 		return glm::tan(pi_over_2 - angle);
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> cot(vecType<T, P> const & x)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> cot(vecType<L, T, P> const & x)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'cot' only accept floating-point inputs");
-		return detail::functor1<T, T, P, vecType>::call(cot, x);
+		return detail::functor1<L, T, T, P>::call(cot, x);
 	}
 
 	// asec
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER genType asec(genType x)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'asec' only accept floating-point values");
 		return acos(genType(1) / x);
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> asec(vecType<T, P> const & x)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> asec(vecType<L, T, P> const & x)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'asec' only accept floating-point inputs");
-		return detail::functor1<T, T, P, vecType>::call(asec, x);
+		return detail::functor1<L, T, T, P>::call(asec, x);
 	}
 
 	// acsc
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER genType acsc(genType x)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'acsc' only accept floating-point values");
 		return asin(genType(1) / x);
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> acsc(vecType<T, P> const & x)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> acsc(vecType<L, T, P> const & x)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'acsc' only accept floating-point inputs");
-		return detail::functor1<T, T, P, vecType>::call(acsc, x);
+		return detail::functor1<L, T, T, P>::call(acsc, x);
 	}
 
 	// acot
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER genType acot(genType x)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'acot' only accept floating-point values");
@@ -93,100 +93,100 @@ namespace glm
 		return pi_over_2 - atan(x);
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> acot(vecType<T, P> const & x)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> acot(vecType<L, T, P> const & x)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'acot' only accept floating-point inputs");
-		return detail::functor1<T, T, P, vecType>::call(acot, x);
+		return detail::functor1<L, T, T, P>::call(acot, x);
 	}
 
 	// sech
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER genType sech(genType angle)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'sech' only accept floating-point values");
 		return genType(1) / glm::cosh(angle);
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> sech(vecType<T, P> const & x)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> sech(vecType<L, T, P> const & x)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'sech' only accept floating-point inputs");
-		return detail::functor1<T, T, P, vecType>::call(sech, x);
+		return detail::functor1<L, T, T, P>::call(sech, x);
 	}
 
 	// csch
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER genType csch(genType angle)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'csch' only accept floating-point values");
 		return genType(1) / glm::sinh(angle);
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> csch(vecType<T, P> const & x)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> csch(vecType<L, T, P> const & x)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'csch' only accept floating-point inputs");
-		return detail::functor1<T, T, P, vecType>::call(csch, x);
+		return detail::functor1<L, T, T, P>::call(csch, x);
 	}
 
 	// coth
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER genType coth(genType angle)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'coth' only accept floating-point values");
 		return glm::cosh(angle) / glm::sinh(angle);
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> coth(vecType<T, P> const & x)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> coth(vecType<L, T, P> const & x)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'coth' only accept floating-point inputs");
-		return detail::functor1<T, T, P, vecType>::call(coth, x);
+		return detail::functor1<L, T, T, P>::call(coth, x);
 	}
 
 	// asech
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER genType asech(genType x)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'asech' only accept floating-point values");
 		return acosh(genType(1) / x);
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> asech(vecType<T, P> const & x)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> asech(vecType<L, T, P> const & x)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'asech' only accept floating-point inputs");
-		return detail::functor1<T, T, P, vecType>::call(asech, x);
+		return detail::functor1<L, T, T, P>::call(asech, x);
 	}
 
 	// acsch
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER genType acsch(genType x)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'acsch' only accept floating-point values");
 		return acsch(genType(1) / x);
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> acsch(vecType<T, P> const & x)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> acsch(vecType<L, T, P> const & x)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'acsch' only accept floating-point inputs");
-		return detail::functor1<T, T, P, vecType>::call(acsch, x);
+		return detail::functor1<L, T, T, P>::call(acsch, x);
 	}
 
 	// acoth
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER genType acoth(genType x)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'acoth' only accept floating-point values");
 		return atanh(genType(1) / x);
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> acoth(vecType<T, P> const & x)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> acoth(vecType<L, T, P> const & x)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'acoth' only accept floating-point inputs");
-		return detail::functor1<T, T, P, vecType>::call(acoth, x);
+		return detail::functor1<L, T, T, P>::call(acoth, x);
 	}
 }//namespace glm
diff --git a/glm/gtc/round.hpp b/glm/gtc/round.hpp
index a5835921..3520e436 100644
--- a/glm/gtc/round.hpp
+++ b/glm/gtc/round.hpp
@@ -33,72 +33,72 @@ namespace glm
 	/// Return true if the value is a power of two number.
 	///
 	/// @see gtc_round
-	template <typename genIUType>
+	template<typename genIUType>
 	GLM_FUNC_DECL bool isPowerOfTwo(genIUType Value);
 
 	/// Return true if the value is a power of two number.
 	///
 	/// @see gtc_round
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<bool, P> isPowerOfTwo(vecType<T, P> const & value);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, bool, P> isPowerOfTwo(vecType<L, T, P> const & value);
 
 	/// Return the power of two number which value is just higher the input value,
 	/// round up to a power of two.
 	///
 	/// @see gtc_round
-	template <typename genIUType>
+	template<typename genIUType>
 	GLM_FUNC_DECL genIUType ceilPowerOfTwo(genIUType Value);
 
 	/// Return the power of two number which value is just higher the input value,
 	/// round up to a power of two.
 	///
 	/// @see gtc_round
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> ceilPowerOfTwo(vecType<T, P> const & value);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, T, P> ceilPowerOfTwo(vecType<L, T, P> const & value);
 
 	/// Return the power of two number which value is just lower the input value,
 	/// round down to a power of two.
 	///
 	/// @see gtc_round
-	template <typename genIUType>
+	template<typename genIUType>
 	GLM_FUNC_DECL genIUType floorPowerOfTwo(genIUType Value);
 
 	/// Return the power of two number which value is just lower the input value,
 	/// round down to a power of two.
 	///
 	/// @see gtc_round
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> floorPowerOfTwo(vecType<T, P> const & value);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, T, P> floorPowerOfTwo(vecType<L, T, P> const & value);
 
 	/// Return the power of two number which value is the closet to the input value.
 	///
 	/// @see gtc_round
-	template <typename genIUType>
+	template<typename genIUType>
 	GLM_FUNC_DECL genIUType roundPowerOfTwo(genIUType Value);
 
 	/// Return the power of two number which value is the closet to the input value.
 	///
 	/// @see gtc_round
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> roundPowerOfTwo(vecType<T, P> const & value);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, T, P> roundPowerOfTwo(vecType<L, T, P> const & value);
 
 	/// Return true if the 'Value' is a multiple of 'Multiple'.
 	///
 	/// @see gtc_round
-	template <typename genIUType>
+	template<typename genIUType>
 	GLM_FUNC_DECL bool isMultiple(genIUType Value, genIUType Multiple);
 
 	/// Return true if the 'Value' is a multiple of 'Multiple'.
 	///
 	/// @see gtc_round
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<bool, P> isMultiple(vecType<T, P> const & Value, T Multiple);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, bool, P> isMultiple(vecType<L, T, P> const & Value, T Multiple);
 
 	/// Return true if the 'Value' is a multiple of 'Multiple'.
 	///
 	/// @see gtc_round
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<bool, P> isMultiple(vecType<T, P> const & Value, vecType<T, P> const & Multiple);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, bool, P> isMultiple(vecType<L, T, P> const & Value, vecType<L, T, P> const & Multiple);
 
 	/// Higher multiple number of Source.
 	///
@@ -107,7 +107,7 @@ namespace glm
 	/// @param Multiple Must be a null or positive value
 	///
 	/// @see gtc_round
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL genType ceilMultiple(genType Source, genType Multiple);
 
 	/// Higher multiple number of Source.
@@ -117,8 +117,8 @@ namespace glm
 	/// @param Multiple Must be a null or positive value
 	///
 	/// @see gtc_round
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> ceilMultiple(vecType<T, P> const & Source, vecType<T, P> const & Multiple);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, T, P> ceilMultiple(vecType<L, T, P> const & Source, vecType<L, T, P> const & Multiple);
 
 	/// Lower multiple number of Source.
 	///
@@ -127,7 +127,7 @@ namespace glm
 	/// @param Multiple Must be a null or positive value
 	///
 	/// @see gtc_round
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL genType floorMultiple(
 		genType Source,
 		genType Multiple);
@@ -139,10 +139,10 @@ namespace glm
 	/// @param Multiple Must be a null or positive value
 	///
 	/// @see gtc_round
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> floorMultiple(
-		vecType<T, P> const & Source,
-		vecType<T, P> const & Multiple);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, T, P> floorMultiple(
+		vecType<L, T, P> const& Source,
+		vecType<L, T, P> const& Multiple);
 
 	/// Lower multiple number of Source.
 	///
@@ -151,7 +151,7 @@ namespace glm
 	/// @param Multiple Must be a null or positive value
 	///
 	/// @see gtc_round
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL genType roundMultiple(
 		genType Source,
 		genType Multiple);
@@ -163,10 +163,10 @@ namespace glm
 	/// @param Multiple Must be a null or positive value
 	///
 	/// @see gtc_round
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> roundMultiple(
-		vecType<T, P> const & Source,
-		vecType<T, P> const & Multiple);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, T, P> roundMultiple(
+		vecType<L, T, P> const& Source,
+		vecType<L, T, P> const& Multiple);
 
 	/// @}
 } //namespace glm
diff --git a/glm/gtc/round.inl b/glm/gtc/round.inl
index f583c403..9ddf50ea 100644
--- a/glm/gtc/round.inl
+++ b/glm/gtc/round.inl
@@ -6,73 +6,73 @@
 namespace glm{
 namespace detail
 {
-	template <typename T, precision P, template <typename, precision> class vecType, bool compute = false>
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType, bool compute = false>
 	struct compute_ceilShift
 	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & v, T)
+		GLM_FUNC_QUALIFIER static vecType<L, T, P> call(vecType<L, T, P> const & v, T)
 		{
 			return v;
 		}
 	};
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	struct compute_ceilShift<T, P, vecType, true>
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	struct compute_ceilShift<L, T, P, vecType, true>
 	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & v, T Shift)
+		GLM_FUNC_QUALIFIER static vecType<L, T, P> call(vecType<L, T, P> const & v, T Shift)
 		{
 			return v | (v >> Shift);
 		}
 	};
 
-	template <typename T, precision P, template <typename, precision> class vecType, bool isSigned = true>
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType, bool isSigned = true>
 	struct compute_ceilPowerOfTwo
 	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x)
+		GLM_FUNC_QUALIFIER static vecType<L, T, P> call(vecType<L, T, P> const & x)
 		{
 			GLM_STATIC_ASSERT(!std::numeric_limits<T>::is_iec559, "'ceilPowerOfTwo' only accept integer scalar or vector inputs");
 
-			vecType<T, P> const Sign(sign(x));
+			vecType<L, T, P> const Sign(sign(x));
 
-			vecType<T, P> v(abs(x));
+			vecType<L, T, P> v(abs(x));
 
 			v = v - static_cast<T>(1);
 			v = v | (v >> static_cast<T>(1));
 			v = v | (v >> static_cast<T>(2));
 			v = v | (v >> static_cast<T>(4));
-			v = compute_ceilShift<T, P, vecType, sizeof(T) >= 2>::call(v, 8);
-			v = compute_ceilShift<T, P, vecType, sizeof(T) >= 4>::call(v, 16);
-			v = compute_ceilShift<T, P, vecType, sizeof(T) >= 8>::call(v, 32);
+			v = compute_ceilShift<L, T, P, vecType, sizeof(T) >= 2>::call(v, 8);
+			v = compute_ceilShift<L, T, P, vecType, sizeof(T) >= 4>::call(v, 16);
+			v = compute_ceilShift<L, T, P, vecType, sizeof(T) >= 8>::call(v, 32);
 			return (v + static_cast<T>(1)) * Sign;
 		}
 	};
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	struct compute_ceilPowerOfTwo<T, P, vecType, false>
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	struct compute_ceilPowerOfTwo<L, T, P, vecType, false>
 	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x)
+		GLM_FUNC_QUALIFIER static vecType<L, T, P> call(vecType<L, T, P> const & x)
 		{
 			GLM_STATIC_ASSERT(!std::numeric_limits<T>::is_iec559, "'ceilPowerOfTwo' only accept integer scalar or vector inputs");
 
-			vecType<T, P> v(x);
+			vecType<L, T, P> v(x);
 
 			v = v - static_cast<T>(1);
 			v = v | (v >> static_cast<T>(1));
 			v = v | (v >> static_cast<T>(2));
 			v = v | (v >> static_cast<T>(4));
-			v = compute_ceilShift<T, P, vecType, sizeof(T) >= 2>::call(v, 8);
-			v = compute_ceilShift<T, P, vecType, sizeof(T) >= 4>::call(v, 16);
-			v = compute_ceilShift<T, P, vecType, sizeof(T) >= 8>::call(v, 32);
+			v = compute_ceilShift<L, T, P, vecType, sizeof(T) >= 2>::call(v, 8);
+			v = compute_ceilShift<L, T, P, vecType, sizeof(T) >= 4>::call(v, 16);
+			v = compute_ceilShift<L, T, P, vecType, sizeof(T) >= 8>::call(v, 32);
 			return v + static_cast<T>(1);
 		}
 	};
 
-	template <bool is_float, bool is_signed>
+	template<bool is_float, bool is_signed>
 	struct compute_ceilMultiple{};
 
-	template <>
+	template<>
 	struct compute_ceilMultiple<true, true>
 	{
-		template <typename genType>
+		template<typename genType>
 		GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple)
 		{
 			if(Source > genType(0))
@@ -82,10 +82,10 @@ namespace detail
 		}
 	};
 
-	template <>
+	template<>
 	struct compute_ceilMultiple<false, false>
 	{
-		template <typename genType>
+		template<typename genType>
 		GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple)
 		{
 			genType Tmp = Source - genType(1);
@@ -93,10 +93,10 @@ namespace detail
 		}
 	};
 
-	template <>
+	template<>
 	struct compute_ceilMultiple<false, true>
 	{
-		template <typename genType>
+		template<typename genType>
 		GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple)
 		{
 			if(Source > genType(0))
@@ -109,13 +109,13 @@ namespace detail
 		}
 	};
 
-	template <bool is_float, bool is_signed>
+	template<bool is_float, bool is_signed>
 	struct compute_floorMultiple{};
 
-	template <>
+	template<>
 	struct compute_floorMultiple<true, true>
 	{
-		template <typename genType>
+		template<typename genType>
 		GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple)
 		{
 			if(Source >= genType(0))
@@ -125,10 +125,10 @@ namespace detail
 		}
 	};
 
-	template <>
+	template<>
 	struct compute_floorMultiple<false, false>
 	{
-		template <typename genType>
+		template<typename genType>
 		GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple)
 		{
 			if(Source >= genType(0))
@@ -141,10 +141,10 @@ namespace detail
 		}
 	};
 
-	template <>
+	template<>
 	struct compute_floorMultiple<false, true>
 	{
-		template <typename genType>
+		template<typename genType>
 		GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple)
 		{
 			if(Source >= genType(0))
@@ -157,13 +157,13 @@ namespace detail
 		}
 	};
 
-	template <bool is_float, bool is_signed>
+	template<bool is_float, bool is_signed>
 	struct compute_roundMultiple{};
 
-	template <>
+	template<>
 	struct compute_roundMultiple<true, true>
 	{
-		template <typename genType>
+		template<typename genType>
 		GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple)
 		{
 			if(Source >= genType(0))
@@ -176,10 +176,10 @@ namespace detail
 		}
 	};
 
-	template <>
+	template<>
 	struct compute_roundMultiple<false, false>
 	{
-		template <typename genType>
+		template<typename genType>
 		GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple)
 		{
 			if(Source >= genType(0))
@@ -192,10 +192,10 @@ namespace detail
 		}
 	};
 
-	template <>
+	template<>
 	struct compute_roundMultiple<false, true>
 	{
-		template <typename genType>
+		template<typename genType>
 		GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple)
 		{
 			if(Source >= genType(0))
@@ -212,54 +212,54 @@ namespace detail
 	////////////////
 	// isPowerOfTwo
 
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER bool isPowerOfTwo(genType Value)
 	{
 		genType const Result = glm::abs(Value);
 		return !(Result & (Result - 1));
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<bool, P> isPowerOfTwo(vecType<T, P> const & Value)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, bool, P> isPowerOfTwo(vecType<L, T, P> const & Value)
 	{
-		vecType<T, P> const Result(abs(Value));
-		return equal(Result & (Result - 1), vecType<T, P>(0));
+		vecType<L, T, P> const Result(abs(Value));
+		return equal(Result & (Result - 1), vecType<L, T, P>(0));
 	}
 
 	//////////////////
 	// ceilPowerOfTwo
 
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER genType ceilPowerOfTwo(genType value)
 	{
-		return detail::compute_ceilPowerOfTwo<genType, defaultp, tvec1, std::numeric_limits<genType>::is_signed>::call(tvec1<genType, defaultp>(value)).x;
+		return detail::compute_ceilPowerOfTwo<1, genType, defaultp, vec, std::numeric_limits<genType>::is_signed>::call(vec<1, genType, defaultp>(value)).x;
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> ceilPowerOfTwo(vecType<T, P> const & v)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> ceilPowerOfTwo(vecType<L, T, P> const & v)
 	{
-		return detail::compute_ceilPowerOfTwo<T, P, vecType, std::numeric_limits<T>::is_signed>::call(v);
+		return detail::compute_ceilPowerOfTwo<L, T, P, vecType, std::numeric_limits<T>::is_signed>::call(v);
 	}
 
 	///////////////////
 	// floorPowerOfTwo
 
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER genType floorPowerOfTwo(genType value)
 	{
 		return isPowerOfTwo(value) ? value : static_cast<genType>(1) << findMSB(value);
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> floorPowerOfTwo(vecType<T, P> const & v)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> floorPowerOfTwo(vecType<L, T, P> const & v)
 	{
-		return detail::functor1<T, T, P, vecType>::call(floorPowerOfTwo, v);
+		return detail::functor1<L, T, T, P>::call(floorPowerOfTwo, v);
 	}
 
 	///////////////////
 	// roundPowerOfTwo
 
-	template <typename genIUType>
+	template<typename genIUType>
 	GLM_FUNC_QUALIFIER genIUType roundPowerOfTwo(genIUType value)
 	{
 		if(isPowerOfTwo(value))
@@ -270,75 +270,75 @@ namespace detail
 		return (next - value) < (value - prev) ? next : prev;
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> roundPowerOfTwo(vecType<T, P> const & v)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> roundPowerOfTwo(vecType<L, T, P> const & v)
 	{
-		return detail::functor1<T, T, P, vecType>::call(roundPowerOfTwo, v);
+		return detail::functor1<L, T, T, P>::call(roundPowerOfTwo, v);
 	}
 
 	////////////////
 	// isMultiple
 
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER bool isMultiple(genType Value, genType Multiple)
 	{
-		return isMultiple(tvec1<genType>(Value), tvec1<genType>(Multiple)).x;
+		return isMultiple(vec<1, genType>(Value), vec<1, genType>(Multiple)).x;
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<bool, P> isMultiple(vecType<T, P> const & Value, T Multiple)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, bool, P> isMultiple(vecType<L, T, P> const & Value, T Multiple)
 	{
-		return (Value % Multiple) == vecType<T, P>(0);
+		return (Value % Multiple) == vecType<L, T, P>(0);
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<bool, P> isMultiple(vecType<T, P> const & Value, vecType<T, P> const & Multiple)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, bool, P> isMultiple(vecType<L, T, P> const & Value, vecType<L, T, P> const & Multiple)
 	{
-		return (Value % Multiple) == vecType<T, P>(0);
+		return (Value % Multiple) == vecType<L, T, P>(0);
 	}
 
 	//////////////////////
 	// ceilMultiple
 
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER genType ceilMultiple(genType Source, genType Multiple)
 	{
 		return detail::compute_ceilMultiple<std::numeric_limits<genType>::is_iec559, std::numeric_limits<genType>::is_signed>::call(Source, Multiple);
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> ceilMultiple(vecType<T, P> const & Source, vecType<T, P> const & Multiple)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> ceilMultiple(vecType<L, T, P> const & Source, vecType<L, T, P> const & Multiple)
 	{
-		return detail::functor2<T, P, vecType>::call(ceilMultiple, Source, Multiple);
+		return detail::functor2<L, T, P>::call(ceilMultiple, Source, Multiple);
 	}
 
 	//////////////////////
 	// floorMultiple
 
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER genType floorMultiple(genType Source, genType Multiple)
 	{
 		return detail::compute_floorMultiple<std::numeric_limits<genType>::is_iec559, std::numeric_limits<genType>::is_signed>::call(Source, Multiple);
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> floorMultiple(vecType<T, P> const & Source, vecType<T, P> const & Multiple)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> floorMultiple(vecType<L, T, P> const & Source, vecType<L, T, P> const & Multiple)
 	{
-		return detail::functor2<T, P, vecType>::call(floorMultiple, Source, Multiple);
+		return detail::functor2<L, T, P>::call(floorMultiple, Source, Multiple);
 	}
 
 	//////////////////////
 	// roundMultiple
 
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER genType roundMultiple(genType Source, genType Multiple)
 	{
 		return detail::compute_roundMultiple<std::numeric_limits<genType>::is_iec559, std::numeric_limits<genType>::is_signed>::call(Source, Multiple);
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> roundMultiple(vecType<T, P> const & Source, vecType<T, P> const & Multiple)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> roundMultiple(vecType<L, T, P> const & Source, vecType<L, T, P> const & Multiple)
 	{
-		return detail::functor2<T, P, vecType>::call(roundMultiple, Source, Multiple);
+		return detail::functor2<L, T, P>::call(roundMultiple, Source, Multiple);
 	}
 }//namespace glm
diff --git a/glm/gtc/type_aligned.hpp b/glm/gtc/type_aligned.hpp
index 2e4503c3..fb81498a 100644
--- a/glm/gtc/type_aligned.hpp
+++ b/glm/gtc/type_aligned.hpp
@@ -25,214 +25,210 @@
 
 namespace glm
 {
-	template <typename T, precision P> struct tvec1;
-	template <typename T, precision P> struct tvec2;
-	template <typename T, precision P> struct tvec3;
-	template <typename T, precision P> struct tvec4;
 	/// @addtogroup gtc_type_aligned
 	/// @{
 
 	// -- *vec1 --
 
-	typedef tvec1<float, aligned_highp>		aligned_highp_vec1;
-	typedef tvec1<float, aligned_mediump>	aligned_mediump_vec1;
-	typedef tvec1<float, aligned_lowp>		aligned_lowp_vec1;
-	typedef tvec1<double, aligned_highp>	aligned_highp_dvec1;
-	typedef tvec1<double, aligned_mediump>	aligned_mediump_dvec1;
-	typedef tvec1<double, aligned_lowp>		aligned_lowp_dvec1;
-	typedef tvec1<int, aligned_highp>		aligned_highp_ivec1;
-	typedef tvec1<int, aligned_mediump>		aligned_mediump_ivec1;
-	typedef tvec1<int, aligned_lowp>		aligned_lowp_ivec1;
-	typedef tvec1<uint, aligned_highp>		aligned_highp_uvec1;
-	typedef tvec1<uint, aligned_mediump>	aligned_mediump_uvec1;
-	typedef tvec1<uint, aligned_lowp>		aligned_lowp_uvec1;
-	typedef tvec1<bool, aligned_highp>		aligned_highp_bvec1;
-	typedef tvec1<bool, aligned_mediump>	aligned_mediump_bvec1;
-	typedef tvec1<bool, aligned_lowp>		aligned_lowp_bvec1;
+	typedef vec<1, float, aligned_highp>		aligned_highp_vec1;
+	typedef vec<1, float, aligned_mediump>	aligned_mediump_vec1;
+	typedef vec<1, float, aligned_lowp>		aligned_lowp_vec1;
+	typedef vec<1, double, aligned_highp>	aligned_highp_dvec1;
+	typedef vec<1, double, aligned_mediump>	aligned_mediump_dvec1;
+	typedef vec<1, double, aligned_lowp>		aligned_lowp_dvec1;
+	typedef vec<1, int, aligned_highp>		aligned_highp_ivec1;
+	typedef vec<1, int, aligned_mediump>		aligned_mediump_ivec1;
+	typedef vec<1, int, aligned_lowp>		aligned_lowp_ivec1;
+	typedef vec<1, uint, aligned_highp>		aligned_highp_uvec1;
+	typedef vec<1, uint, aligned_mediump>	aligned_mediump_uvec1;
+	typedef vec<1, uint, aligned_lowp>		aligned_lowp_uvec1;
+	typedef vec<1, bool, aligned_highp>		aligned_highp_bvec1;
+	typedef vec<1, bool, aligned_mediump>	aligned_mediump_bvec1;
+	typedef vec<1, bool, aligned_lowp>		aligned_lowp_bvec1;
 
-	typedef tvec1<float, packed_highp>		packed_highp_vec1;
-	typedef tvec1<float, packed_mediump>	packed_mediump_vec1;
-	typedef tvec1<float, packed_lowp>		packed_lowp_vec1;
-	typedef tvec1<double, packed_highp>		packed_highp_dvec1;
-	typedef tvec1<double, packed_mediump>	packed_mediump_dvec1;
-	typedef tvec1<double, packed_lowp>		packed_lowp_dvec1;
-	typedef tvec1<int, packed_highp>		packed_highp_ivec1;
-	typedef tvec1<int, packed_mediump>		packed_mediump_ivec1;
-	typedef tvec1<int, packed_lowp>			packed_lowp_ivec1;
-	typedef tvec1<uint, packed_highp>		packed_highp_uvec1;
-	typedef tvec1<uint, packed_mediump>		packed_mediump_uvec1;
-	typedef tvec1<uint, packed_lowp>		packed_lowp_uvec1;
-	typedef tvec1<bool, packed_highp>		packed_highp_bvec1;
-	typedef tvec1<bool, packed_mediump>		packed_mediump_bvec1;
-	typedef tvec1<bool, packed_lowp>		packed_lowp_bvec1;
+	typedef vec<1, float, packed_highp>		packed_highp_vec1;
+	typedef vec<1, float, packed_mediump>	packed_mediump_vec1;
+	typedef vec<1, float, packed_lowp>		packed_lowp_vec1;
+	typedef vec<1, double, packed_highp>		packed_highp_dvec1;
+	typedef vec<1, double, packed_mediump>	packed_mediump_dvec1;
+	typedef vec<1, double, packed_lowp>		packed_lowp_dvec1;
+	typedef vec<1, int, packed_highp>		packed_highp_ivec1;
+	typedef vec<1, int, packed_mediump>		packed_mediump_ivec1;
+	typedef vec<1, int, packed_lowp>			packed_lowp_ivec1;
+	typedef vec<1, uint, packed_highp>		packed_highp_uvec1;
+	typedef vec<1, uint, packed_mediump>		packed_mediump_uvec1;
+	typedef vec<1, uint, packed_lowp>		packed_lowp_uvec1;
+	typedef vec<1, bool, packed_highp>		packed_highp_bvec1;
+	typedef vec<1, bool, packed_mediump>		packed_mediump_bvec1;
+	typedef vec<1, bool, packed_lowp>		packed_lowp_bvec1;
 
 	// -- *vec2 --
 
 	/// 2 components vector of high single-precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
-	typedef tvec2<float, aligned_highp>		aligned_highp_vec2;
+	typedef vec<2, float, aligned_highp>		aligned_highp_vec2;
 
 	/// 2 components vector of medium single-precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
-	typedef tvec2<float, aligned_mediump>	aligned_mediump_vec2;
+	typedef vec<2, float, aligned_mediump>	aligned_mediump_vec2;
 
 	/// 2 components vector of low single-precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
-	typedef tvec2<float, aligned_lowp>		aligned_lowp_vec2;
+	typedef vec<2, float, aligned_lowp>		aligned_lowp_vec2;
 
 	/// 2 components vector of high double-precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
-	typedef tvec2<double, aligned_highp>	aligned_highp_dvec2;
+	typedef vec<2, double, aligned_highp>	aligned_highp_dvec2;
 
 	/// 2 components vector of medium double-precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
-	typedef tvec2<double, aligned_mediump>	aligned_mediump_dvec2;
+	typedef vec<2, double, aligned_mediump>	aligned_mediump_dvec2;
 
 	/// 2 components vector of low double-precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
-	typedef tvec2<double, aligned_lowp>		aligned_lowp_dvec2;
+	typedef vec<2, double, aligned_lowp>		aligned_lowp_dvec2;
 
 	/// 2 components vector of high precision signed integer numbers.
 	/// There is no guarantee on the actual precision.
-	typedef tvec2<int, aligned_highp>		aligned_highp_ivec2;
+	typedef vec<2, int, aligned_highp>		aligned_highp_ivec2;
 
 	/// 2 components vector of medium precision signed integer numbers.
 	/// There is no guarantee on the actual precision.
-	typedef tvec2<int, aligned_mediump>		aligned_mediump_ivec2;
+	typedef vec<2, int, aligned_mediump>		aligned_mediump_ivec2;
 
 	/// 2 components vector of low precision signed integer numbers.
 	/// There is no guarantee on the actual precision.
-	typedef tvec2<int, aligned_lowp>		aligned_lowp_ivec2;
+	typedef vec<2, int, aligned_lowp>		aligned_lowp_ivec2;
 
 	/// 2 components vector of high precision unsigned integer numbers.
 	/// There is no guarantee on the actual precision.
-	typedef tvec2<uint, aligned_highp>		aligned_highp_uvec2;
+	typedef vec<2, uint, aligned_highp>		aligned_highp_uvec2;
 
 	/// 2 components vector of medium precision unsigned integer numbers.
 	/// There is no guarantee on the actual precision.
-	typedef tvec2<uint, aligned_mediump>	aligned_mediump_uvec2;
+	typedef vec<2, uint, aligned_mediump>	aligned_mediump_uvec2;
 
 	/// 2 components vector of low precision unsigned integer numbers.
 	/// There is no guarantee on the actual precision.
-	typedef tvec2<uint, aligned_lowp>		aligned_lowp_uvec2;
+	typedef vec<2, uint, aligned_lowp>		aligned_lowp_uvec2;
 
 	/// 2 components vector of high precision bool numbers.
 	/// There is no guarantee on the actual precision.
-	typedef tvec2<bool, aligned_highp>		aligned_highp_bvec2;
+	typedef vec<2, bool, aligned_highp>		aligned_highp_bvec2;
 
 	/// 2 components vector of medium precision bool numbers.
 	/// There is no guarantee on the actual precision.
-	typedef tvec2<bool, aligned_mediump>	aligned_mediump_bvec2;
+	typedef vec<2, bool, aligned_mediump>	aligned_mediump_bvec2;
 
 	/// 2 components vector of low precision bool numbers.
 	/// There is no guarantee on the actual precision.
-	typedef tvec2<bool, aligned_lowp>		aligned_lowp_bvec2;
+	typedef vec<2, bool, aligned_lowp>		aligned_lowp_bvec2;
 
 	// -- *vec3 --
 
 	/// 3 components vector of high single-precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
-	typedef tvec3<float, aligned_highp>		aligned_highp_vec3;
+	typedef vec<3, float, aligned_highp>		aligned_highp_vec3;
 
 	/// 3 components vector of medium single-precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
-	typedef tvec3<float, aligned_mediump>	aligned_mediump_vec3;
+	typedef vec<3, float, aligned_mediump>	aligned_mediump_vec3;
 
 	/// 3 components vector of low single-precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
-	typedef tvec3<float, aligned_lowp>		aligned_lowp_vec3;
+	typedef vec<3, float, aligned_lowp>		aligned_lowp_vec3;
 
 	/// 3 components vector of high double-precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
-	typedef tvec3<double, aligned_highp>	aligned_highp_dvec3;
+	typedef vec<3, double, aligned_highp>	aligned_highp_dvec3;
 
 	/// 3 components vector of medium double-precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
-	typedef tvec3<double, aligned_mediump>	aligned_mediump_dvec3;
+	typedef vec<3, double, aligned_mediump>	aligned_mediump_dvec3;
 
 	/// 3 components vector of low double-precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
-	typedef tvec3<double, aligned_lowp>		aligned_lowp_dvec3;
+	typedef vec<3, double, aligned_lowp>		aligned_lowp_dvec3;
 
 	/// 3 components vector of high precision signed integer numbers.
 	/// There is no guarantee on the actual precision.
-	typedef tvec3<int, aligned_highp>		aligned_highp_ivec3;
+	typedef vec<3, int, aligned_highp>		aligned_highp_ivec3;
 
 	/// 3 components vector of medium precision signed integer numbers.
 	/// There is no guarantee on the actual precision.
-	typedef tvec3<int, aligned_mediump>		aligned_mediump_ivec3;
+	typedef vec<3, int, aligned_mediump>		aligned_mediump_ivec3;
 
 	/// 3 components vector of low precision signed integer numbers.
 	/// There is no guarantee on the actual precision.
-	typedef tvec3<int, aligned_lowp>		aligned_lowp_ivec3;
+	typedef vec<3, int, aligned_lowp>		aligned_lowp_ivec3;
 
 	/// 3 components vector of high precision unsigned integer numbers.
 	/// There is no guarantee on the actual precision.
-	typedef tvec3<uint, aligned_highp>		aligned_highp_uvec3;
+	typedef vec<3, uint, aligned_highp>		aligned_highp_uvec3;
 
 	/// 3 components vector of medium precision unsigned integer numbers.
 	/// There is no guarantee on the actual precision.
-	typedef tvec3<uint, aligned_mediump>	aligned_mediump_uvec3;
+	typedef vec<3, uint, aligned_mediump>	aligned_mediump_uvec3;
 
 	/// 3 components vector of low precision unsigned integer numbers.
 	/// There is no guarantee on the actual precision.
-	typedef tvec3<uint, aligned_lowp>		aligned_lowp_uvec3;
+	typedef vec<3, uint, aligned_lowp>		aligned_lowp_uvec3;
 
 	/// 3 components vector of high precision bool numbers.
-	typedef tvec3<bool, aligned_highp>		aligned_highp_bvec3;
+	typedef vec<3, bool, aligned_highp>		aligned_highp_bvec3;
 
 	/// 3 components vector of medium precision bool numbers.
-	typedef tvec3<bool, aligned_mediump>	aligned_mediump_bvec3;
+	typedef vec<3, bool, aligned_mediump>	aligned_mediump_bvec3;
 
 	/// 3 components vector of low precision bool numbers.
-	typedef tvec3<bool, aligned_lowp>		aligned_lowp_bvec3;
+	typedef vec<3, bool, aligned_lowp>		aligned_lowp_bvec3;
 
 	// -- *vec4 --
 
 	/// 4 components vector of high single-precision floating-point numbers.
-	typedef tvec4<float, aligned_highp>		aligned_highp_vec4;
+	typedef vec<4, float, aligned_highp>		aligned_highp_vec4;
 
 	/// 4 components vector of medium single-precision floating-point numbers.
-	typedef tvec4<float, aligned_mediump>	aligned_mediump_vec4;
+	typedef vec<4, float, aligned_mediump>	aligned_mediump_vec4;
 
 	/// 4 components vector of low single-precision floating-point numbers.
-	typedef tvec4<float, aligned_lowp>		aligned_lowp_vec4;
+	typedef vec<4, float, aligned_lowp>		aligned_lowp_vec4;
 
 	/// 4 components vector of high double-precision floating-point numbers.
-	typedef tvec4<double, aligned_highp>	aligned_highp_dvec4;
+	typedef vec<4, double, aligned_highp>	aligned_highp_dvec4;
 
 	/// 4 components vector of medium double-precision floating-point numbers.
-	typedef tvec4<double, aligned_mediump>	aligned_mediump_dvec4;
+	typedef vec<4, double, aligned_mediump>	aligned_mediump_dvec4;
 
 	/// 4 components vector of low double-precision floating-point numbers.
-	typedef tvec4<double, aligned_lowp>		aligned_lowp_dvec4;
+	typedef vec<4, double, aligned_lowp>		aligned_lowp_dvec4;
 
 	/// 4 components vector of high precision signed integer numbers.
-	typedef tvec4<int, aligned_highp>		aligned_highp_ivec4;
+	typedef vec<4, int, aligned_highp>		aligned_highp_ivec4;
 
 	/// 4 components vector of medium precision signed integer numbers.
-	typedef tvec4<int, aligned_mediump>		aligned_mediump_ivec4;
+	typedef vec<4, int, aligned_mediump>		aligned_mediump_ivec4;
 
 	/// 4 components vector of low precision signed integer numbers.
-	typedef tvec4<int, aligned_lowp>		aligned_lowp_ivec4;
+	typedef vec<4, int, aligned_lowp>		aligned_lowp_ivec4;
 
 	/// 4 components vector of high precision unsigned integer numbers.
-	typedef tvec4<uint, aligned_highp>		aligned_highp_uvec4;
+	typedef vec<4, uint, aligned_highp>		aligned_highp_uvec4;
 
 	/// 4 components vector of medium precision unsigned integer numbers.
-	typedef tvec4<uint, aligned_mediump>	aligned_mediump_uvec4;
+	typedef vec<4, uint, aligned_mediump>	aligned_mediump_uvec4;
 
 	/// 4 components vector of low precision unsigned integer numbers.
-	typedef tvec4<uint, aligned_lowp>		aligned_lowp_uvec4;
+	typedef vec<4, uint, aligned_lowp>		aligned_lowp_uvec4;
 
 	/// 4 components vector of high precision bool numbers.
-	typedef tvec4<bool, aligned_highp>		aligned_highp_bvec4;
+	typedef vec<4, bool, aligned_highp>		aligned_highp_bvec4;
 
 	/// 4 components vector of medium precision bool numbers.
-	typedef tvec4<bool, aligned_mediump>	aligned_mediump_bvec4;
+	typedef vec<4, bool, aligned_mediump>	aligned_mediump_bvec4;
 
 	/// 4 components vector of low precision bool numbers.
-	typedef tvec4<bool, aligned_lowp>		aligned_lowp_bvec4;
+	typedef vec<4, bool, aligned_lowp>		aligned_lowp_bvec4;
 
 	// -- default --
 
diff --git a/glm/gtc/type_precision.hpp b/glm/gtc/type_precision.hpp
index 5e6f0b8e..101f427c 100644
--- a/glm/gtc/type_precision.hpp
+++ b/glm/gtc/type_precision.hpp
@@ -247,70 +247,70 @@ namespace glm
 
 	/// 8 bit signed integer scalar type.
 	/// @see gtc_type_precision
-	typedef tvec1<i8, defaultp> i8vec1;
+	typedef vec<1, i8, defaultp> i8vec1;
 	
 	/// 8 bit signed integer vector of 2 components type.
 	/// @see gtc_type_precision
-	typedef tvec2<i8, defaultp> i8vec2;
+	typedef vec<2, i8, defaultp> i8vec2;
 
 	/// 8 bit signed integer vector of 3 components type.
 	/// @see gtc_type_precision
-	typedef tvec3<i8, defaultp> i8vec3;
+	typedef vec<3, i8, defaultp> i8vec3;
 
 	/// 8 bit signed integer vector of 4 components type.
 	/// @see gtc_type_precision
-	typedef tvec4<i8, defaultp> i8vec4;
+	typedef vec<4, i8, defaultp> i8vec4;
 
 
 	/// 16 bit signed integer scalar type.
 	/// @see gtc_type_precision
-	typedef tvec1<i16, defaultp> i16vec1;
+	typedef vec<1, i16, defaultp> i16vec1;
 	
 	/// 16 bit signed integer vector of 2 components type.
 	/// @see gtc_type_precision
-	typedef tvec2<i16, defaultp> i16vec2;
+	typedef vec<2, i16, defaultp> i16vec2;
 
 	/// 16 bit signed integer vector of 3 components type.
 	/// @see gtc_type_precision
-	typedef tvec3<i16, defaultp> i16vec3;
+	typedef vec<3, i16, defaultp> i16vec3;
 
 	/// 16 bit signed integer vector of 4 components type.
 	/// @see gtc_type_precision
-	typedef tvec4<i16, defaultp> i16vec4;
+	typedef vec<4, i16, defaultp> i16vec4;
 
 
 	/// 32 bit signed integer scalar type.
 	/// @see gtc_type_precision
-	typedef tvec1<i32, defaultp> i32vec1;
+	typedef vec<1, i32, defaultp> i32vec1;
 	
 	/// 32 bit signed integer vector of 2 components type.
 	/// @see gtc_type_precision
-	typedef tvec2<i32, defaultp> i32vec2;
+	typedef vec<2, i32, defaultp> i32vec2;
 
 	/// 32 bit signed integer vector of 3 components type.
 	/// @see gtc_type_precision
-	typedef tvec3<i32, defaultp> i32vec3;
+	typedef vec<3, i32, defaultp> i32vec3;
 
 	/// 32 bit signed integer vector of 4 components type.
 	/// @see gtc_type_precision
-	typedef tvec4<i32, defaultp> i32vec4;
+	typedef vec<4, i32, defaultp> i32vec4;
 
 
 	/// 64 bit signed integer scalar type.
 	/// @see gtc_type_precision
-	typedef tvec1<i64, defaultp> i64vec1;
+	typedef vec<1, i64, defaultp> i64vec1;
 	
 	/// 64 bit signed integer vector of 2 components type.
 	/// @see gtc_type_precision
-	typedef tvec2<i64, defaultp> i64vec2;
+	typedef vec<2, i64, defaultp> i64vec2;
 
 	/// 64 bit signed integer vector of 3 components type.
 	/// @see gtc_type_precision
-	typedef tvec3<i64, defaultp> i64vec3;
+	typedef vec<3, i64, defaultp> i64vec3;
 
 	/// 64 bit signed integer vector of 4 components type.
 	/// @see gtc_type_precision
-	typedef tvec4<i64, defaultp> i64vec4;
+	typedef vec<4, i64, defaultp> i64vec4;
 
 
 	/////////////////////////////
@@ -519,70 +519,70 @@ namespace glm
 
 	/// Default precision 8 bit unsigned integer scalar type.
 	/// @see gtc_type_precision
-	typedef tvec1<u8, defaultp> u8vec1;
+	typedef vec<1, u8, defaultp> u8vec1;
 	
 	/// Default precision 8 bit unsigned integer vector of 2 components type.
 	/// @see gtc_type_precision
-	typedef tvec2<u8, defaultp> u8vec2;
+	typedef vec<2, u8, defaultp> u8vec2;
 
 	/// Default precision 8 bit unsigned integer vector of 3 components type.
 	/// @see gtc_type_precision
-	typedef tvec3<u8, defaultp> u8vec3;
+	typedef vec<3, u8, defaultp> u8vec3;
 
 	/// Default precision 8 bit unsigned integer vector of 4 components type.
 	/// @see gtc_type_precision
-	typedef tvec4<u8, defaultp> u8vec4;
+	typedef vec<4, u8, defaultp> u8vec4;
 
 
 	/// Default precision 16 bit unsigned integer scalar type.
 	/// @see gtc_type_precision
-	typedef tvec1<u16, defaultp> u16vec1;
+	typedef vec<1, u16, defaultp> u16vec1;
 	
 	/// Default precision 16 bit unsigned integer vector of 2 components type.
 	/// @see gtc_type_precision
-	typedef tvec2<u16, defaultp> u16vec2;
+	typedef vec<2, u16, defaultp> u16vec2;
 
 	/// Default precision 16 bit unsigned integer vector of 3 components type.
 	/// @see gtc_type_precision
-	typedef tvec3<u16, defaultp> u16vec3;
+	typedef vec<3, u16, defaultp> u16vec3;
 
 	/// Default precision 16 bit unsigned integer vector of 4 components type.
 	/// @see gtc_type_precision
-	typedef tvec4<u16, defaultp> u16vec4;
+	typedef vec<4, u16, defaultp> u16vec4;
 
 
 	/// Default precision 32 bit unsigned integer scalar type.
 	/// @see gtc_type_precision
-	typedef tvec1<u32, defaultp> u32vec1;
+	typedef vec<1, u32, defaultp> u32vec1;
 	
 	/// Default precision 32 bit unsigned integer vector of 2 components type.
 	/// @see gtc_type_precision
-	typedef tvec2<u32, defaultp> u32vec2;
+	typedef vec<2, u32, defaultp> u32vec2;
 
 	/// Default precision 32 bit unsigned integer vector of 3 components type.
 	/// @see gtc_type_precision
-	typedef tvec3<u32, defaultp> u32vec3;
+	typedef vec<3, u32, defaultp> u32vec3;
 
 	/// Default precision 32 bit unsigned integer vector of 4 components type.
 	/// @see gtc_type_precision
-	typedef tvec4<u32, defaultp> u32vec4;
+	typedef vec<4, u32, defaultp> u32vec4;
 
 
 	/// Default precision 64 bit unsigned integer scalar type.
 	/// @see gtc_type_precision
-	typedef tvec1<u64, defaultp> u64vec1;
+	typedef vec<1, u64, defaultp> u64vec1;
 	
 	/// Default precision 64 bit unsigned integer vector of 2 components type.
 	/// @see gtc_type_precision
-	typedef tvec2<u64, defaultp> u64vec2;
+	typedef vec<2, u64, defaultp> u64vec2;
 
 	/// Default precision 64 bit unsigned integer vector of 3 components type.
 	/// @see gtc_type_precision
-	typedef tvec3<u64, defaultp> u64vec3;
+	typedef vec<3, u64, defaultp> u64vec3;
 
 	/// Default precision 64 bit unsigned integer vector of 4 components type.
 	/// @see gtc_type_precision
-	typedef tvec4<u64, defaultp> u64vec4;
+	typedef vec<4, u64, defaultp> u64vec4;
 
 
 	//////////////////////
@@ -617,53 +617,53 @@ namespace glm
 
 	/// Single-precision floating-point vector of 1 component.
 	/// @see gtc_type_precision
-	typedef tvec1<float, defaultp> fvec1;
+	typedef vec<1, float, defaultp> fvec1;
 
 	/// Single-precision floating-point vector of 2 components.
 	/// @see gtc_type_precision
-	typedef tvec2<float, defaultp> fvec2;
+	typedef vec<2, float, defaultp> fvec2;
 
 	/// Single-precision floating-point vector of 3 components.
 	/// @see gtc_type_precision
-	typedef tvec3<float, defaultp> fvec3;
+	typedef vec<3, float, defaultp> fvec3;
 
 	/// Single-precision floating-point vector of 4 components.
 	/// @see gtc_type_precision
-	typedef tvec4<float, defaultp> fvec4;
+	typedef vec<4, float, defaultp> fvec4;
 
 	
 	/// Single-precision floating-point vector of 1 component.
 	/// @see gtc_type_precision
-	typedef tvec1<f32, defaultp> f32vec1;
+	typedef vec<1, f32, defaultp> f32vec1;
 
 	/// Single-precision floating-point vector of 2 components.
 	/// @see gtc_type_precision
-	typedef tvec2<f32, defaultp> f32vec2;
+	typedef vec<2, f32, defaultp> f32vec2;
 
 	/// Single-precision floating-point vector of 3 components.
 	/// @see gtc_type_precision
-	typedef tvec3<f32, defaultp> f32vec3;
+	typedef vec<3, f32, defaultp> f32vec3;
 
 	/// Single-precision floating-point vector of 4 components.
 	/// @see gtc_type_precision
-	typedef tvec4<f32, defaultp> f32vec4;
+	typedef vec<4, f32, defaultp> f32vec4;
 
 
 	/// Double-precision floating-point vector of 1 component.
 	/// @see gtc_type_precision
-	typedef tvec1<f64, defaultp> f64vec1;
+	typedef vec<1, f64, defaultp> f64vec1;
 
 	/// Double-precision floating-point vector of 2 components.
 	/// @see gtc_type_precision
-	typedef tvec2<f64, defaultp> f64vec2;
+	typedef vec<2, f64, defaultp> f64vec2;
 
 	/// Double-precision floating-point vector of 3 components.
 	/// @see gtc_type_precision
-	typedef tvec3<f64, defaultp> f64vec3;
+	typedef vec<3, f64, defaultp> f64vec3;
 
 	/// Double-precision floating-point vector of 4 components.
 	/// @see gtc_type_precision
-	typedef tvec4<f64, defaultp> f64vec4;
+	typedef vec<4, f64, defaultp> f64vec4;
 
 
 	//////////////////////
@@ -675,15 +675,15 @@ namespace glm
 
 	/// Single-precision floating-point 2x2 matrix.
 	/// @see gtc_type_precision
-	typedef tmat2x2<f32, defaultp> fmat2;
+	typedef mat<2, 2, f32, defaultp> fmat2;
 
 	/// Single-precision floating-point 3x3 matrix.
 	/// @see gtc_type_precision
-	typedef tmat3x3<f32, defaultp> fmat3;
+	typedef mat<3, 3, f32, defaultp> fmat3;
 
 	/// Single-precision floating-point 4x4 matrix.
 	/// @see gtc_type_precision
-	typedef tmat4x4<f32, defaultp> fmat4;
+	typedef mat<4, 4, f32, defaultp> fmat4;
 
 
 	/// Single-precision floating-point 1x1 matrix.
@@ -692,39 +692,39 @@ namespace glm
 
 	/// Single-precision floating-point 2x2 matrix.
 	/// @see gtc_type_precision
-	typedef tmat2x2<f32, defaultp> fmat2x2;
+	typedef mat<2, 2, f32, defaultp> fmat2x2;
 
 	/// Single-precision floating-point 2x3 matrix.
 	/// @see gtc_type_precision
-	typedef tmat2x3<f32, defaultp> fmat2x3;
+	typedef mat<2, 3, f32, defaultp> fmat2x3;
 
 	/// Single-precision floating-point 2x4 matrix.
 	/// @see gtc_type_precision
-	typedef tmat2x4<f32, defaultp> fmat2x4;
+	typedef mat<2, 4, f32, defaultp> fmat2x4;
 
 	/// Single-precision floating-point 3x2 matrix.
 	/// @see gtc_type_precision
-	typedef tmat3x2<f32, defaultp> fmat3x2;
+	typedef mat<3, 2, f32, defaultp> fmat3x2;
 
 	/// Single-precision floating-point 3x3 matrix.
 	/// @see gtc_type_precision
-	typedef tmat3x3<f32, defaultp> fmat3x3;
+	typedef mat<3, 3, f32, defaultp> fmat3x3;
 
 	/// Single-precision floating-point 3x4 matrix.
 	/// @see gtc_type_precision
-	typedef tmat3x4<f32, defaultp> fmat3x4;
+	typedef mat<3, 4, f32, defaultp> fmat3x4;
 
 	/// Single-precision floating-point 4x2 matrix.
 	/// @see gtc_type_precision
-	typedef tmat4x2<f32, defaultp> fmat4x2;
+	typedef mat<4, 2, f32, defaultp> fmat4x2;
 
 	/// Single-precision floating-point 4x3 matrix.
 	/// @see gtc_type_precision
-	typedef tmat4x3<f32, defaultp> fmat4x3;
+	typedef mat<4, 3, f32, defaultp> fmat4x3;
 
 	/// Single-precision floating-point 4x4 matrix.
 	/// @see gtc_type_precision
-	typedef tmat4x4<f32, defaultp> fmat4x4;
+	typedef mat<4, 4, f32, defaultp> fmat4x4;
 
 
 	/// Single-precision floating-point 1x1 matrix.
@@ -733,15 +733,15 @@ namespace glm
 
 	/// Single-precision floating-point 2x2 matrix.
 	/// @see gtc_type_precision
-	typedef tmat2x2<f32, defaultp> f32mat2;
+	typedef mat<2, 2, f32, defaultp> f32mat2;
 
 	/// Single-precision floating-point 3x3 matrix.
 	/// @see gtc_type_precision
-	typedef tmat3x3<f32, defaultp> f32mat3;
+	typedef mat<3, 3, f32, defaultp> f32mat3;
 
 	/// Single-precision floating-point 4x4 matrix.
 	/// @see gtc_type_precision
-	typedef tmat4x4<f32, defaultp> f32mat4;
+	typedef mat<4, 4, f32, defaultp> f32mat4;
 
 
 	/// Single-precision floating-point 1x1 matrix.
@@ -750,39 +750,39 @@ namespace glm
 
 	/// Single-precision floating-point 2x2 matrix.
 	/// @see gtc_type_precision
-	typedef tmat2x2<f32, defaultp> f32mat2x2;
+	typedef mat<2, 2, f32, defaultp> f32mat2x2;
 
 	/// Single-precision floating-point 2x3 matrix.
 	/// @see gtc_type_precision
-	typedef tmat2x3<f32, defaultp> f32mat2x3;
+	typedef mat<2, 3, f32, defaultp> f32mat2x3;
 
 	/// Single-precision floating-point 2x4 matrix.
 	/// @see gtc_type_precision
-	typedef tmat2x4<f32, defaultp> f32mat2x4;
+	typedef mat<2, 4, f32, defaultp> f32mat2x4;
 
 	/// Single-precision floating-point 3x2 matrix.
 	/// @see gtc_type_precision
-	typedef tmat3x2<f32, defaultp> f32mat3x2;
+	typedef mat<3, 2, f32, defaultp> f32mat3x2;
 
 	/// Single-precision floating-point 3x3 matrix.
 	/// @see gtc_type_precision
-	typedef tmat3x3<f32, defaultp> f32mat3x3;
+	typedef mat<3, 3, f32, defaultp> f32mat3x3;
 
 	/// Single-precision floating-point 3x4 matrix.
 	/// @see gtc_type_precision
-	typedef tmat3x4<f32, defaultp> f32mat3x4;
+	typedef mat<3, 4, f32, defaultp> f32mat3x4;
 
 	/// Single-precision floating-point 4x2 matrix.
 	/// @see gtc_type_precision
-	typedef tmat4x2<f32, defaultp> f32mat4x2;
+	typedef mat<4, 2, f32, defaultp> f32mat4x2;
 
 	/// Single-precision floating-point 4x3 matrix.
 	/// @see gtc_type_precision
-	typedef tmat4x3<f32, defaultp> f32mat4x3;
+	typedef mat<4, 3, f32, defaultp> f32mat4x3;
 
 	/// Single-precision floating-point 4x4 matrix.
 	/// @see gtc_type_precision
-	typedef tmat4x4<f32, defaultp> f32mat4x4;
+	typedef mat<4, 4, f32, defaultp> f32mat4x4;
 
 
 	/// Double-precision floating-point 1x1 matrix.
@@ -791,15 +791,15 @@ namespace glm
 
 	/// Double-precision floating-point 2x2 matrix.
 	/// @see gtc_type_precision
-	typedef tmat2x2<f64, defaultp> f64mat2;
+	typedef mat<2, 2, f64, defaultp> f64mat2;
 
 	/// Double-precision floating-point 3x3 matrix.
 	/// @see gtc_type_precision
-	typedef tmat3x3<f64, defaultp> f64mat3;
+	typedef mat<3, 3, f64, defaultp> f64mat3;
 
 	/// Double-precision floating-point 4x4 matrix.
 	/// @see gtc_type_precision
-	typedef tmat4x4<f64, defaultp> f64mat4;
+	typedef mat<4, 4, f64, defaultp> f64mat4;
 
 
 	/// Double-precision floating-point 1x1 matrix.
@@ -808,39 +808,39 @@ namespace glm
 
 	/// Double-precision floating-point 2x2 matrix.
 	/// @see gtc_type_precision
-	typedef tmat2x2<f64, defaultp> f64mat2x2;
+	typedef mat<2, 2, f64, defaultp> f64mat2x2;
 
 	/// Double-precision floating-point 2x3 matrix.
 	/// @see gtc_type_precision
-	typedef tmat2x3<f64, defaultp> f64mat2x3;
+	typedef mat<2, 3, f64, defaultp> f64mat2x3;
 
 	/// Double-precision floating-point 2x4 matrix.
 	/// @see gtc_type_precision
-	typedef tmat2x4<f64, defaultp> f64mat2x4;
+	typedef mat<2, 4, f64, defaultp> f64mat2x4;
 
 	/// Double-precision floating-point 3x2 matrix.
 	/// @see gtc_type_precision
-	typedef tmat3x2<f64, defaultp> f64mat3x2;
+	typedef mat<3, 2, f64, defaultp> f64mat3x2;
 
 	/// Double-precision floating-point 3x3 matrix.
 	/// @see gtc_type_precision
-	typedef tmat3x3<f64, defaultp> f64mat3x3;
+	typedef mat<3, 3, f64, defaultp> f64mat3x3;
 
 	/// Double-precision floating-point 3x4 matrix.
 	/// @see gtc_type_precision
-	typedef tmat3x4<f64, defaultp> f64mat3x4;
+	typedef mat<3, 4, f64, defaultp> f64mat3x4;
 
 	/// Double-precision floating-point 4x2 matrix.
 	/// @see gtc_type_precision
-	typedef tmat4x2<f64, defaultp> f64mat4x2;
+	typedef mat<4, 2, f64, defaultp> f64mat4x2;
 
 	/// Double-precision floating-point 4x3 matrix.
 	/// @see gtc_type_precision
-	typedef tmat4x3<f64, defaultp> f64mat4x3;
+	typedef mat<4, 3, f64, defaultp> f64mat4x3;
 
 	/// Double-precision floating-point 4x4 matrix.
 	/// @see gtc_type_precision
-	typedef tmat4x4<f64, defaultp> f64mat4x4;
+	typedef mat<4, 4, f64, defaultp> f64mat4x4;
 
 
 	//////////////////////////
diff --git a/glm/gtc/type_ptr.hpp b/glm/gtc/type_ptr.hpp
index b2977da0..a9b13044 100644
--- a/glm/gtc/type_ptr.hpp
+++ b/glm/gtc/type_ptr.hpp
@@ -60,82 +60,82 @@ namespace glm
 	/// Return the constant address to the data of the input parameter.
 	/// @see gtc_type_ptr
 	template<typename genType>
-	GLM_FUNC_DECL typename genType::value_type const * value_ptr(genType const & vec);
+	GLM_FUNC_DECL typename genType::value_type const * value_ptr(genType const& v);
 
 	/// Build a vector from a pointer.
 	/// @see gtc_type_ptr
 	template<typename T>
-	GLM_FUNC_DECL tvec2<T, defaultp> make_vec2(T const * const ptr);
+	GLM_FUNC_DECL vec<2, T, defaultp> make_vec2(T const * const ptr);
 
 	/// Build a vector from a pointer.
 	/// @see gtc_type_ptr
 	template<typename T>
-	GLM_FUNC_DECL tvec3<T, defaultp> make_vec3(T const * const ptr);
+	GLM_FUNC_DECL vec<3, T, defaultp> make_vec3(T const * const ptr);
 
 	/// Build a vector from a pointer.
 	/// @see gtc_type_ptr
 	template<typename T>
-	GLM_FUNC_DECL tvec4<T, defaultp> make_vec4(T const * const ptr);
+	GLM_FUNC_DECL vec<4, T, defaultp> make_vec4(T const * const ptr);
 
 	/// Build a matrix from a pointer.
 	/// @see gtc_type_ptr
 	template<typename T>
-	GLM_FUNC_DECL tmat2x2<T, defaultp> make_mat2x2(T const * const ptr);
+	GLM_FUNC_DECL mat<2, 2, T, defaultp> make_mat2x2(T const * const ptr);
 
 	/// Build a matrix from a pointer.
 	/// @see gtc_type_ptr
 	template<typename T>
-	GLM_FUNC_DECL tmat2x3<T, defaultp> make_mat2x3(T const * const ptr);
+	GLM_FUNC_DECL mat<2, 3, T, defaultp> make_mat2x3(T const * const ptr);
 
 	/// Build a matrix from a pointer.
 	/// @see gtc_type_ptr
 	template<typename T>
-	GLM_FUNC_DECL tmat2x4<T, defaultp> make_mat2x4(T const * const ptr);
+	GLM_FUNC_DECL mat<2, 4, T, defaultp> make_mat2x4(T const * const ptr);
 
 	/// Build a matrix from a pointer.
 	/// @see gtc_type_ptr
 	template<typename T>
-	GLM_FUNC_DECL tmat3x2<T, defaultp> make_mat3x2(T const * const ptr);
+	GLM_FUNC_DECL mat<3, 2, T, defaultp> make_mat3x2(T const * const ptr);
 
 	/// Build a matrix from a pointer.
 	/// @see gtc_type_ptr
 	template<typename T>
-	GLM_FUNC_DECL tmat3x3<T, defaultp> make_mat3x3(T const * const ptr);
+	GLM_FUNC_DECL mat<3, 3, T, defaultp> make_mat3x3(T const * const ptr);
 
 	/// Build a matrix from a pointer.
 	/// @see gtc_type_ptr
 	template<typename T>
-	GLM_FUNC_DECL tmat3x4<T, defaultp> make_mat3x4(T const * const ptr);
+	GLM_FUNC_DECL mat<3, 4, T, defaultp> make_mat3x4(T const * const ptr);
 
 	/// Build a matrix from a pointer.
 	/// @see gtc_type_ptr
 	template<typename T>
-	GLM_FUNC_DECL tmat4x2<T, defaultp> make_mat4x2(T const * const ptr);
+	GLM_FUNC_DECL mat<4, 2, T, defaultp> make_mat4x2(T const * const ptr);
 
 	/// Build a matrix from a pointer.
 	/// @see gtc_type_ptr
 	template<typename T>
-	GLM_FUNC_DECL tmat4x3<T, defaultp> make_mat4x3(T const * const ptr);
+	GLM_FUNC_DECL mat<4, 3, T, defaultp> make_mat4x3(T const * const ptr);
 
 	/// Build a matrix from a pointer.
 	/// @see gtc_type_ptr
 	template<typename T>
-	GLM_FUNC_DECL tmat4x4<T, defaultp> make_mat4x4(T const * const ptr);
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> make_mat4x4(T const * const ptr);
 	
 	/// Build a matrix from a pointer.
 	/// @see gtc_type_ptr
 	template<typename T>
-	GLM_FUNC_DECL tmat2x2<T, defaultp> make_mat2(T const * const ptr);
+	GLM_FUNC_DECL mat<2, 2, T, defaultp> make_mat2(T const * const ptr);
 
 	/// Build a matrix from a pointer.
 	/// @see gtc_type_ptr
 	template<typename T>
-	GLM_FUNC_DECL tmat3x3<T, defaultp> make_mat3(T const * const ptr);
+	GLM_FUNC_DECL mat<3, 3, T, defaultp> make_mat3(T const * const ptr);
 		
 	/// Build a matrix from a pointer.
 	/// @see gtc_type_ptr
 	template<typename T>
-	GLM_FUNC_DECL tmat4x4<T, defaultp> make_mat4(T const * const ptr);
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> make_mat4(T const * const ptr);
 
 	/// Build a quaternion from a pointer.
 	/// @see gtc_type_ptr
diff --git a/glm/gtc/type_ptr.inl b/glm/gtc/type_ptr.inl
index 3aa6ae6c..1b2392cf 100644
--- a/glm/gtc/type_ptr.inl
+++ b/glm/gtc/type_ptr.inl
@@ -11,271 +11,199 @@ namespace glm
 	/// Return the constant address to the data of the vector input.
 	/// @see gtc_type_ptr
 	template<typename T, precision P>
-	GLM_FUNC_QUALIFIER T const * value_ptr
-	(
-		tvec2<T, P> const & vec
-	)
+	GLM_FUNC_QUALIFIER T const* value_ptr(vec<2, T, P> const& v)
 	{
-		return &(vec.x);
+		return &(v.x);
 	}
 
 	//! Return the address to the data of the vector input.
 	/// @see gtc_type_ptr
 	template<typename T, precision P>
-	GLM_FUNC_QUALIFIER T * value_ptr
-	(
-		tvec2<T, P> & vec
-	)
+	GLM_FUNC_QUALIFIER T* value_ptr(vec<2, T, P>& v)
 	{
-		return &(vec.x);
+		return &(v.x);
 	}
 
 	/// Return the constant address to the data of the vector input.
 	/// @see gtc_type_ptr
 	template<typename T, precision P>
-	GLM_FUNC_QUALIFIER T const * value_ptr
-	(
-		tvec3<T, P> const & vec
-	)
+	GLM_FUNC_QUALIFIER T const * value_ptr(vec<3, T, P> const& v)
 	{
-		return &(vec.x);
+		return &(v.x);
 	}
 
 	//! Return the address to the data of the vector input.
 	/// @see gtc_type_ptr
 	template<typename T, precision P>
-	GLM_FUNC_QUALIFIER T * value_ptr
-	(
-		tvec3<T, P> & vec
-	)
+	GLM_FUNC_QUALIFIER T* value_ptr(vec<3, T, P>& v)
 	{
-		return &(vec.x);
+		return &(v.x);
 	}
 		
 	/// Return the constant address to the data of the vector input.
 	/// @see gtc_type_ptr
 	template<typename T, precision P>
-	GLM_FUNC_QUALIFIER T const * value_ptr
-	(	
-		tvec4<T, P> const & vec
-	)
+	GLM_FUNC_QUALIFIER T const* value_ptr(vec<4, T, P> const& v)
 	{
-		return &(vec.x);
+		return &(v.x);
 	}
 
 	//! Return the address to the data of the vector input.
 	//! From GLM_GTC_type_ptr extension.
 	template<typename T, precision P>
-	GLM_FUNC_QUALIFIER T * value_ptr
-	(	
-		tvec4<T, P> & vec
-	)
+	GLM_FUNC_QUALIFIER T* value_ptr(vec<4, T, P>& v)
 	{
-		return &(vec.x);
+		return &(v.x);
 	}
 
 	/// Return the constant address to the data of the matrix input.
 	/// @see gtc_type_ptr
 	template<typename T, precision P>
-	GLM_FUNC_QUALIFIER T const * value_ptr
-	(
-		tmat2x2<T, P> const & mat
-	)
+	GLM_FUNC_QUALIFIER T const* value_ptr(mat<2, 2, T, P> const& m)
 	{
-		return &(mat[0].x);
+		return &(m[0].x);
 	}
 
 	//! Return the address to the data of the matrix input.
 	/// @see gtc_type_ptr
 	template<typename T, precision P>
-	GLM_FUNC_QUALIFIER T * value_ptr
-	(
-		tmat2x2<T, P> & mat
-	)
+	GLM_FUNC_QUALIFIER T* value_ptr(mat<2, 2, T, P>& m)
 	{
-		return &(mat[0].x);
+		return &(m[0].x);
 	}
-		
+
 	/// Return the constant address to the data of the matrix input.
 	/// @see gtc_type_ptr
 	template<typename T, precision P>
-	GLM_FUNC_QUALIFIER T const * value_ptr
-	(
-		tmat3x3<T, P> const & mat
-	)
+	GLM_FUNC_QUALIFIER T const* value_ptr(mat<3, 3, T, P> const& m)
 	{
-		return &(mat[0].x);
+		return &(m[0].x);
 	}
 
 	//! Return the address to the data of the matrix input.
 	/// @see gtc_type_ptr
 	template<typename T, precision P>
-	GLM_FUNC_QUALIFIER T * value_ptr
-	(
-		tmat3x3<T, P> & mat
-	)
+	GLM_FUNC_QUALIFIER T* value_ptr(mat<3, 3, T, P>& m)
 	{
-		return &(mat[0].x);
+		return &(m[0].x);
 	}
 		
 	/// Return the constant address to the data of the matrix input.
 	/// @see gtc_type_ptr
 	template<typename T, precision P>
-	GLM_FUNC_QUALIFIER T const * value_ptr
-	(
-		tmat4x4<T, P> const & mat
-	)
+	GLM_FUNC_QUALIFIER T const* value_ptr(mat<4, 4, T, P> const& m)
 	{
-		return &(mat[0].x);
+		return &(m[0].x);
 	}
 
 	//! Return the address to the data of the matrix input.
 	//! From GLM_GTC_type_ptr extension.
 	template<typename T, precision P>
-	GLM_FUNC_QUALIFIER T * value_ptr
-	(
-		tmat4x4<T, P> & mat
-	)
+	GLM_FUNC_QUALIFIER T* value_ptr(mat<4, 4, T, P>& m)
 	{
-		return &(mat[0].x);
+		return &(m[0].x);
 	}
 
 	/// Return the constant address to the data of the matrix input.
 	/// @see gtc_type_ptr
 	template<typename T, precision P>
-	GLM_FUNC_QUALIFIER T const * value_ptr
-	(
-		tmat2x3<T, P> const & mat
-	)
+	GLM_FUNC_QUALIFIER T const* value_ptr(mat<2, 3, T, P> const& m)
 	{
-		return &(mat[0].x);
+		return &(m[0].x);
 	}
 
 	//! Return the address to the data of the matrix input.
 	/// @see gtc_type_ptr
 	template<typename T, precision P>
-	GLM_FUNC_QUALIFIER T * value_ptr
-	(
-		tmat2x3<T, P> & mat
-	)
+	GLM_FUNC_QUALIFIER T* value_ptr(mat<2, 3, T, P>& m)
 	{
-		return &(mat[0].x);
+		return &(m[0].x);
 	}
 		
 	/// Return the constant address to the data of the matrix input.
 	/// @see gtc_type_ptr
 	template<typename T, precision P>
-	GLM_FUNC_QUALIFIER T const * value_ptr
-	(
-		tmat3x2<T, P> const & mat
-	)
+	GLM_FUNC_QUALIFIER T const* value_ptr(mat<3, 2, T, P> const& m)
 	{
-		return &(mat[0].x);
+		return &(m[0].x);
 	}
 
 	//! Return the address to the data of the matrix input.
 	/// @see gtc_type_ptr
 	template<typename T, precision P>
-	GLM_FUNC_QUALIFIER T * value_ptr
-	(
-		tmat3x2<T, P> & mat
-	)
+	GLM_FUNC_QUALIFIER T* value_ptr(mat<3, 2, T, P>& m)
 	{
-		return &(mat[0].x);
+		return &(m[0].x);
 	}
 		
 	/// Return the constant address to the data of the matrix input.
 	/// @see gtc_type_ptr
 	template<typename T, precision P>
-	GLM_FUNC_QUALIFIER T const * value_ptr
-	(
-		tmat2x4<T, P> const & mat
-	)
+	GLM_FUNC_QUALIFIER T const* value_ptr(mat<2, 4, T, P> const& m)
 	{
-		return &(mat[0].x);
+		return &(m[0].x);
 	}
 
 	//! Return the address to the data of the matrix input.
 	/// @see gtc_type_ptr
 	template<typename T, precision P>
-	GLM_FUNC_QUALIFIER T * value_ptr
-	(
-		tmat2x4<T, P> & mat
-	)
+	GLM_FUNC_QUALIFIER T* value_ptr(mat<2, 4, T, P>& m)
 	{
-		return &(mat[0].x);
+		return &(m[0].x);
 	}
 		
 	/// Return the constant address to the data of the matrix input.
 	/// @see gtc_type_ptr
 	template<typename T, precision P>
-	GLM_FUNC_QUALIFIER T const * value_ptr
-	(
-		tmat4x2<T, P> const & mat
-	)
+	GLM_FUNC_QUALIFIER T const* value_ptr(mat<4, 2, T, P> const& m)
 	{
-		return &(mat[0].x);
+		return &(m[0].x);
 	}
 
 	//! Return the address to the data of the matrix input.
 	/// @see gtc_type_ptr
 	template<typename T, precision P>
-	GLM_FUNC_QUALIFIER T * value_ptr
-	(	
-		tmat4x2<T, P> & mat
-	)
+	GLM_FUNC_QUALIFIER T* value_ptr(mat<4, 2, T, P>& m)
 	{
-		return &(mat[0].x);
+		return &(m[0].x);
 	}
 		
 	/// Return the constant address to the data of the matrix input.
 	/// @see gtc_type_ptr
 	template<typename T, precision P>
-	GLM_FUNC_QUALIFIER T const * value_ptr
-	(
-		tmat3x4<T, P> const & mat
-	)
+	GLM_FUNC_QUALIFIER T const* value_ptr(mat<3, 4, T, P> const& m)
 	{
-		return &(mat[0].x);
+		return &(m[0].x);
 	}
 
 	//! Return the address to the data of the matrix input.
 	/// @see gtc_type_ptr
 	template<typename T, precision P>
-	GLM_FUNC_QUALIFIER T * value_ptr
-	(
-		tmat3x4<T, P> & mat
-	)
+	GLM_FUNC_QUALIFIER T* value_ptr(mat<3, 4, T, P>& m)
 	{
-		return &(mat[0].x);
+		return &(m[0].x);
 	}
 		
 	/// Return the constant address to the data of the matrix input.
 	/// @see gtc_type_ptr
 	template<typename T, precision P>
-	GLM_FUNC_QUALIFIER T const * value_ptr
-	(
-		tmat4x3<T, P> const & mat
-	)
+	GLM_FUNC_QUALIFIER T const* value_ptr(mat<4, 3, T, P> const& m)
 	{
-		return &(mat[0].x);
+		return &(m[0].x);
 	}
 
 	/// Return the address to the data of the matrix input.
 	/// @see gtc_type_ptr
 	template<typename T, precision P>
-	GLM_FUNC_QUALIFIER T * value_ptr(tmat4x3<T, P> & mat)
+	GLM_FUNC_QUALIFIER T * value_ptr(mat<4, 3, T, P>& m)
 	{
-		return &(mat[0].x);
+		return &(m[0].x);
 	}
 
 	/// Return the constant address to the data of the input parameter.
 	/// @see gtc_type_ptr
 	template<typename T, precision P>
-	GLM_FUNC_QUALIFIER T const * value_ptr
-	(
-		tquat<T, P> const & q
-	)
+	GLM_FUNC_QUALIFIER T const * value_ptr(tquat<T, P> const& q)
 	{
 		return &(q[0]);
 	}
@@ -283,162 +211,159 @@ namespace glm
 	/// Return the address to the data of the quaternion input.
 	/// @see gtc_type_ptr
 	template<typename T, precision P>
-	GLM_FUNC_QUALIFIER T * value_ptr
-	(
-		tquat<T, P> & q
-	)
+	GLM_FUNC_QUALIFIER T* value_ptr(tquat<T, P>& q)
 	{
 		return &(q[0]);
 	}
 
 	/// Build a vector from a pointer.
 	/// @see gtc_type_ptr
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec2<T, defaultp> make_vec2(T const * const ptr)
+	template<typename T>
+	GLM_FUNC_QUALIFIER vec<2, T, defaultp> make_vec2(T const *const ptr)
 	{
-		tvec2<T, defaultp> Result;
-		memcpy(value_ptr(Result), ptr, sizeof(tvec2<T, defaultp>));
+		vec<2, T, defaultp> Result;
+		memcpy(value_ptr(Result), ptr, sizeof(vec<2, T, defaultp>));
 		return Result;
 	}
 
 	/// Build a vector from a pointer.
 	/// @see gtc_type_ptr
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec3<T, defaultp> make_vec3(T const * const ptr)
+	template<typename T>
+	GLM_FUNC_QUALIFIER vec<3, T, defaultp> make_vec3(T const *const ptr)
 	{
-		tvec3<T, defaultp> Result;
-		memcpy(value_ptr(Result), ptr, sizeof(tvec3<T, defaultp>));
+		vec<3, T, defaultp> Result;
+		memcpy(value_ptr(Result), ptr, sizeof(vec<3, T, defaultp>));
 		return Result;
 	}
 
 	/// Build a vector from a pointer.
 	/// @see gtc_type_ptr
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec4<T, defaultp> make_vec4(T const * const ptr)
+	template<typename T>
+	GLM_FUNC_QUALIFIER vec<4, T, defaultp> make_vec4(T const *const ptr)
 	{
-		tvec4<T, defaultp> Result;
-		memcpy(value_ptr(Result), ptr, sizeof(tvec4<T, defaultp>));
+		vec<4, T, defaultp> Result;
+		memcpy(value_ptr(Result), ptr, sizeof(vec<4, T, defaultp>));
 		return Result;
 	}
 
 	/// Build a matrix from a pointer.
 	/// @see gtc_type_ptr
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat2x2<T, defaultp> make_mat2x2(T const * const ptr)
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, defaultp> make_mat2x2(T const *const ptr)
 	{
-		tmat2x2<T, defaultp> Result;
-		memcpy(value_ptr(Result), ptr, sizeof(tmat2x2<T, defaultp>));
+		mat<2, 2, T, defaultp> Result;
+		memcpy(value_ptr(Result), ptr, sizeof(mat<2, 2, T, defaultp>));
 		return Result;
 	}
 
 	/// Build a matrix from a pointer.
 	/// @see gtc_type_ptr
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat2x3<T, defaultp> make_mat2x3(T const * const ptr)
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<2, 3, T, defaultp> make_mat2x3(T const *const ptr)
 	{
-		tmat2x3<T, defaultp> Result;
-		memcpy(value_ptr(Result), ptr, sizeof(tmat2x3<T, defaultp>));
+		mat<2, 3, T, defaultp> Result;
+		memcpy(value_ptr(Result), ptr, sizeof(mat<2, 3, T, defaultp>));
 		return Result;
 	}
 
 	/// Build a matrix from a pointer.
 	/// @see gtc_type_ptr
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat2x4<T, defaultp> make_mat2x4(T const * const ptr)
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, defaultp> make_mat2x4(T const *const ptr)
 	{
-		tmat2x4<T, defaultp> Result;
-		memcpy(value_ptr(Result), ptr, sizeof(tmat2x4<T, defaultp>));
+		mat<2, 4, T, defaultp> Result;
+		memcpy(value_ptr(Result), ptr, sizeof(mat<2, 4, T, defaultp>));
 		return Result;
 	}
 
 	/// Build a matrix from a pointer.
 	/// @see gtc_type_ptr
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat3x2<T, defaultp> make_mat3x2(T const * const ptr)
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, defaultp> make_mat3x2(T const *const ptr)
 	{
-		tmat3x2<T, defaultp> Result;
-		memcpy(value_ptr(Result), ptr, sizeof(tmat3x2<T, defaultp>));
+		mat<3, 2, T, defaultp> Result;
+		memcpy(value_ptr(Result), ptr, sizeof(mat<3, 2, T, defaultp>));
 		return Result;
 	}
 
 	//! Build a matrix from a pointer.
 	/// @see gtc_type_ptr
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat3x3<T, defaultp> make_mat3x3(T const * const ptr)
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, defaultp> make_mat3x3(T const *const ptr)
 	{
-		tmat3x3<T, defaultp> Result;
-		memcpy(value_ptr(Result), ptr, sizeof(tmat3x3<T, defaultp>));
+		mat<3, 3, T, defaultp> Result;
+		memcpy(value_ptr(Result), ptr, sizeof(mat<3, 3, T, defaultp>));
 		return Result;
 	}
 
 	//! Build a matrix from a pointer.
 	/// @see gtc_type_ptr
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat3x4<T, defaultp> make_mat3x4(T const * const ptr)
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, defaultp> make_mat3x4(T const *const ptr)
 	{
-		tmat3x4<T, defaultp> Result;
-		memcpy(value_ptr(Result), ptr, sizeof(tmat3x4<T, defaultp>));
+		mat<3, 4, T, defaultp> Result;
+		memcpy(value_ptr(Result), ptr, sizeof(mat<3, 4, T, defaultp>));
 		return Result;
 	}
 
 	//! Build a matrix from a pointer.
 	/// @see gtc_type_ptr
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat4x2<T, defaultp> make_mat4x2(T const * const ptr)
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, defaultp> make_mat4x2(T const *const ptr)
 	{
-		tmat4x2<T, defaultp> Result;
-		memcpy(value_ptr(Result), ptr, sizeof(tmat4x2<T, defaultp>));
+		mat<4, 2, T, defaultp> Result;
+		memcpy(value_ptr(Result), ptr, sizeof(mat<4, 2, T, defaultp>));
 		return Result;
 	}
 
 	//! Build a matrix from a pointer.
 	/// @see gtc_type_ptr
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat4x3<T, defaultp> make_mat4x3(T const * const ptr)
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, defaultp> make_mat4x3(T const *const ptr)
 	{
-		tmat4x3<T, defaultp> Result;
-		memcpy(value_ptr(Result), ptr, sizeof(tmat4x3<T, defaultp>));
+		mat<4, 3, T, defaultp> Result;
+		memcpy(value_ptr(Result), ptr, sizeof(mat<4, 3, T, defaultp>));
 		return Result;
 	}
 
 	//! Build a matrix from a pointer.
 	/// @see gtc_type_ptr
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> make_mat4x4(T const * const ptr)
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> make_mat4x4(T const *const ptr)
 	{
-		tmat4x4<T, defaultp> Result;
-		memcpy(value_ptr(Result), ptr, sizeof(tmat4x4<T, defaultp>));
+		mat<4, 4, T, defaultp> Result;
+		memcpy(value_ptr(Result), ptr, sizeof(mat<4, 4, T, defaultp>));
 		return Result;
 	}
 
 	//! Build a matrix from a pointer.
 	/// @see gtc_type_ptr
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat2x2<T, defaultp> make_mat2(T const * const ptr)
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, defaultp> make_mat2(T const *const ptr)
 	{
 		return make_mat2x2(ptr);
 	}
 
 	//! Build a matrix from a pointer.
 	/// @see gtc_type_ptr
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat3x3<T, defaultp> make_mat3(T const * const ptr)
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, defaultp> make_mat3(T const *const ptr)
 	{
 		return make_mat3x3(ptr);
 	}
 		
 	//! Build a matrix from a pointer.
 	/// @see gtc_type_ptr
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> make_mat4(T const * const ptr)
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> make_mat4(T const *const ptr)
 	{
 		return make_mat4x4(ptr);
 	}
 
 	//! Build a quaternion from a pointer.
 	/// @see gtc_type_ptr
-	template <typename T>
-	GLM_FUNC_QUALIFIER tquat<T, defaultp> make_quat(T const * const ptr)
+	template<typename T>
+	GLM_FUNC_QUALIFIER tquat<T, defaultp> make_quat(T const *const ptr)
 	{
 		tquat<T, defaultp> Result;
 		memcpy(value_ptr(Result), ptr, sizeof(tquat<T, defaultp>));
diff --git a/glm/gtc/ulp.hpp b/glm/gtc/ulp.hpp
index a82fa4e7..fb07502c 100644
--- a/glm/gtc/ulp.hpp
+++ b/glm/gtc/ulp.hpp
@@ -29,33 +29,33 @@ namespace glm
 
 	/// Return the next ULP value(s) after the input value(s).
 	/// @see gtc_ulp
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL genType next_float(genType const & x);
 
 	/// Return the previous ULP value(s) before the input value(s).
 	/// @see gtc_ulp
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL genType prev_float(genType const & x);
 
 	/// Return the value(s) ULP distance after the input value(s).
 	/// @see gtc_ulp
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL genType next_float(genType const & x, uint const & Distance);
 
 	/// Return the value(s) ULP distance before the input value(s).
 	/// @see gtc_ulp
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL genType prev_float(genType const & x, uint const & Distance);
 	
 	/// Return the distance in the number of ULP between 2 scalars.
 	/// @see gtc_ulp
-	template <typename T>
+	template<typename T>
 	GLM_FUNC_DECL uint float_distance(T const & x, T const & y);
 
 	/// Return the distance in the number of ULP between 2 vectors.
 	/// @see gtc_ulp
-	template<typename T, template<typename> class vecType>
-	GLM_FUNC_DECL vecType<uint> float_distance(vecType<T> const & x, vecType<T> const & y);
+	template<typename T, template<int, typename> class vecType>
+	GLM_FUNC_DECL vecType<2, uint> float_distance(vecType<2, T> const & x, vecType<2, T> const & y);
 	
 	/// @}
 }// namespace glm
diff --git a/glm/gtc/ulp.inl b/glm/gtc/ulp.inl
index 54c914ab..c5fb0cad 100644
--- a/glm/gtc/ulp.inl
+++ b/glm/gtc/ulp.inl
@@ -171,7 +171,7 @@ namespace detail
 
 namespace glm
 {
-	template <>
+	template<>
 	GLM_FUNC_QUALIFIER float next_float(float const & x)
 	{
 #		if GLM_HAS_CXX11_STL
@@ -185,7 +185,7 @@ namespace glm
 #		endif
 	}
 
-	template <>
+	template<>
 	GLM_FUNC_QUALIFIER double next_float(double const & x)
 	{
 #		if GLM_HAS_CXX11_STL
@@ -199,10 +199,10 @@ namespace glm
 #		endif
 	}
 
-	template<typename T, precision P, template<typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> next_float(vecType<T, P> const & x)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> next_float(vecType<L, T, P> const & x)
 	{
-		vecType<T, P> Result(uninitialize);
+		vecType<L, T, P> Result(uninitialize);
 		for(length_t i = 0, n = Result.length(); i < n; ++i)
 			Result[i] = next_float(x[i]);
 		return Result;
@@ -234,16 +234,16 @@ namespace glm
 #		endif
 	}
 
-	template<typename T, precision P, template<typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> prev_float(vecType<T, P> const & x)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> prev_float(vecType<L, T, P> const & x)
 	{
-		vecType<T, P> Result(uninitialize);
+		vecType<L, T, P> Result(uninitialize);
 		for(length_t i = 0, n = Result.length(); i < n; ++i)
 			Result[i] = prev_float(x[i]);
 		return Result;
 	}
 
-	template <typename T>
+	template<typename T>
 	GLM_FUNC_QUALIFIER T next_float(T const & x, uint const & ulps)
 	{
 		T temp = x;
@@ -252,16 +252,16 @@ namespace glm
 		return temp;
 	}
 
-	template<typename T, precision P, template<typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> next_float(vecType<T, P> const & x, vecType<uint, P> const & ulps)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> next_float(vecType<L, T, P> const & x, vecType<L, uint, P> const & ulps)
 	{
-		vecType<T, P> Result(uninitialize);
+		vecType<L, T, P> Result(uninitialize);
 		for(length_t i = 0, n = Result.length(); i < n; ++i)
 			Result[i] = next_float(x[i], ulps[i]);
 		return Result;
 	}
 
-	template <typename T>
+	template<typename T>
 	GLM_FUNC_QUALIFIER T prev_float(T const & x, uint const & ulps)
 	{
 		T temp = x;
@@ -270,16 +270,16 @@ namespace glm
 		return temp;
 	}
 
-	template<typename T, precision P, template<typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> prev_float(vecType<T, P> const & x, vecType<uint, P> const & ulps)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> prev_float(vecType<L, T, P> const & x, vecType<L, uint, P> const & ulps)
 	{
-		vecType<T, P> Result(uninitialize);
+		vecType<L, T, P> Result(uninitialize);
 		for(length_t i = 0, n = Result.length(); i < n; ++i)
 			Result[i] = prev_float(x[i], ulps[i]);
 		return Result;
 	}
 
-	template <typename T>
+	template<typename T>
 	GLM_FUNC_QUALIFIER uint float_distance(T const & x, T const & y)
 	{
 		uint ulp = 0;
@@ -310,10 +310,10 @@ namespace glm
 		return ulp;
 	}
 
-	template<typename T, precision P, template<typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<uint, P> float_distance(vecType<T, P> const & x, vecType<T, P> const & y)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, uint, P> float_distance(vecType<L, T, P> const & x, vecType<L, T, P> const & y)
 	{
-		vecType<uint, P> Result(uninitialize);
+		vecType<L, uint, P> Result(uninitialize);
 		for(length_t i = 0, n = Result.length(); i < n; ++i)
 			Result[i] = float_distance(x[i], y[i]);
 		return Result;
diff --git a/glm/gtx/associated_min_max.hpp b/glm/gtx/associated_min_max.hpp
index 14ce50c9..ec66bb7f 100644
--- a/glm/gtx/associated_min_max.hpp
+++ b/glm/gtx/associated_min_max.hpp
@@ -35,24 +35,24 @@ namespace glm
 
 	/// Minimum comparison between 2 variables and returns 2 associated variable values
 	/// @see gtx_associated_min_max
-	template<typename T, typename U, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL tvec2<U, P> associatedMin(
-		vecType<T, P> const & x, vecType<U, P> const & a,
-		vecType<T, P> const & y, vecType<U, P> const & b);
+	template<length_t L, typename T, typename U, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vec<2, U, P> associatedMin(
+		vecType<L, T, P> const& x, vecType<L, U, P> const & a,
+		vecType<L, T, P> const& y, vecType<L, U, P> const & b);
 
 	/// Minimum comparison between 2 variables and returns 2 associated variable values
 	/// @see gtx_associated_min_max
-	template<typename T, typename U, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<U, P> associatedMin(
-		T x, const vecType<U, P>& a,
-		T y, const vecType<U, P>& b);
+	template<length_t L, typename T, typename U, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, U, P> associatedMin(
+		T x, const vecType<L, U, P>& a,
+		T y, const vecType<L, U, P>& b);
 
 	/// Minimum comparison between 2 variables and returns 2 associated variable values
 	/// @see gtx_associated_min_max
-	template<typename T, typename U, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<U, P> associatedMin(
-		vecType<T, P> const & x, U a,
-		vecType<T, P> const & y, U b);
+	template<length_t L, typename T, typename U, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, U, P> associatedMin(
+		vecType<L, T, P> const& x, U a,
+		vecType<L, T, P> const& y, U b);
 
 	/// Minimum comparison between 3 variables and returns 3 associated variable values
 	/// @see gtx_associated_min_max
@@ -64,11 +64,11 @@ namespace glm
 
 	/// Minimum comparison between 3 variables and returns 3 associated variable values
 	/// @see gtx_associated_min_max
-	template<typename T, typename U, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<U, P> associatedMin(
-		vecType<T, P> const & x, vecType<U, P> const & a,
-		vecType<T, P> const & y, vecType<U, P> const & b,
-		vecType<T, P> const & z, vecType<U, P> const & c);
+	template<length_t L, typename T, typename U, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, U, P> associatedMin(
+		vecType<L, T, P> const& x, vecType<L, U, P> const & a,
+		vecType<L, T, P> const& y, vecType<L, U, P> const & b,
+		vecType<L, T, P> const& z, vecType<L, U, P> const & c);
 
 	/// Minimum comparison between 4 variables and returns 4 associated variable values
 	/// @see gtx_associated_min_max
@@ -81,30 +81,30 @@ namespace glm
 
 	/// Minimum comparison between 4 variables and returns 4 associated variable values
 	/// @see gtx_associated_min_max
-	template<typename T, typename U, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<U, P> associatedMin(
-		vecType<T, P> const & x, vecType<U, P> const & a,
-		vecType<T, P> const & y, vecType<U, P> const & b,
-		vecType<T, P> const & z, vecType<U, P> const & c,
-		vecType<T, P> const & w, vecType<U, P> const & d);
+	template<length_t L, typename T, typename U, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, U, P> associatedMin(
+		vecType<L, T, P> const& x, vecType<L, U, P> const & a,
+		vecType<L, T, P> const& y, vecType<L, U, P> const & b,
+		vecType<L, T, P> const& z, vecType<L, U, P> const & c,
+		vecType<L, T, P> const& w, vecType<L, U, P> const & d);
 
 	/// Minimum comparison between 4 variables and returns 4 associated variable values
 	/// @see gtx_associated_min_max
-	template<typename T, typename U, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<U, P> associatedMin(
-		T x, vecType<U, P> const & a,
-		T y, vecType<U, P> const & b,
-		T z, vecType<U, P> const & c,
-		T w, vecType<U, P> const & d);
+	template<length_t L, typename T, typename U, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, U, P> associatedMin(
+		T x, vecType<L, U, P> const & a,
+		T y, vecType<L, U, P> const & b,
+		T z, vecType<L, U, P> const & c,
+		T w, vecType<L, U, P> const & d);
 
 	/// Minimum comparison between 4 variables and returns 4 associated variable values
 	/// @see gtx_associated_min_max
-	template<typename T, typename U, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<U, P> associatedMin(
-		vecType<T, P> const & x, U a,
-		vecType<T, P> const & y, U b,
-		vecType<T, P> const & z, U c,
-		vecType<T, P> const & w, U d);
+	template<length_t L, typename T, typename U, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, U, P> associatedMin(
+		vecType<L, T, P> const& x, U a,
+		vecType<L, T, P> const& y, U b,
+		vecType<L, T, P> const& z, U c,
+		vecType<L, T, P> const& w, U d);
 
 	/// Maximum comparison between 2 variables and returns 2 associated variable values
 	/// @see gtx_associated_min_max
@@ -113,24 +113,24 @@ namespace glm
 
 	/// Maximum comparison between 2 variables and returns 2 associated variable values
 	/// @see gtx_associated_min_max
-	template<typename T, typename U, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL tvec2<U, P> associatedMax(
-		vecType<T, P> const & x, vecType<U, P> const & a,
-		vecType<T, P> const & y, vecType<U, P> const & b);
+	template<length_t L, typename T, typename U, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vec<2, U, P> associatedMax(
+		vecType<L, T, P> const& x, vecType<L, U, P> const & a,
+		vecType<L, T, P> const& y, vecType<L, U, P> const & b);
 
 	/// Maximum comparison between 2 variables and returns 2 associated variable values
 	/// @see gtx_associated_min_max
-	template<typename T, typename U, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> associatedMax(
-		T x, vecType<U, P> const & a,
-		T y, vecType<U, P> const & b);
+	template<length_t L, typename T, typename U, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, T, P> associatedMax(
+		T x, vecType<L, U, P> const & a,
+		T y, vecType<L, U, P> const & b);
 
 	/// Maximum comparison between 2 variables and returns 2 associated variable values
 	/// @see gtx_associated_min_max
-	template<typename T, typename U, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<U, P> associatedMax(
-		vecType<T, P> const & x, U a,
-		vecType<T, P> const & y, U b);
+	template<length_t L, typename T, typename U, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, U, P> associatedMax(
+		vecType<L, T, P> const& x, U a,
+		vecType<L, T, P> const& y, U b);
 
 	/// Maximum comparison between 3 variables and returns 3 associated variable values
 	/// @see gtx_associated_min_max
@@ -142,27 +142,27 @@ namespace glm
 
 	/// Maximum comparison between 3 variables and returns 3 associated variable values
 	/// @see gtx_associated_min_max
-	template<typename T, typename U, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<U, P> associatedMax(
-		vecType<T, P> const & x, vecType<U, P> const & a,
-		vecType<T, P> const & y, vecType<U, P> const & b,
-		vecType<T, P> const & z, vecType<U, P> const & c);
+	template<length_t L, typename T, typename U, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, U, P> associatedMax(
+		vecType<L, T, P> const& x, vecType<L, U, P> const & a,
+		vecType<L, T, P> const& y, vecType<L, U, P> const & b,
+		vecType<L, T, P> const& z, vecType<L, U, P> const & c);
 
 	/// Maximum comparison between 3 variables and returns 3 associated variable values
 	/// @see gtx_associated_min_max
-	template<typename T, typename U, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> associatedMax(
-		T x, vecType<U, P> const & a,
-		T y, vecType<U, P> const & b,
-		T z, vecType<U, P> const & c);
+	template<length_t L, typename T, typename U, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, T, P> associatedMax(
+		T x, vecType<L, U, P> const & a,
+		T y, vecType<L, U, P> const & b,
+		T z, vecType<L, U, P> const & c);
 
 	/// Maximum comparison between 3 variables and returns 3 associated variable values
 	/// @see gtx_associated_min_max
-	template<typename T, typename U, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<U, P> associatedMax(
-		vecType<T, P> const & x, U a,
-		vecType<T, P> const & y, U b,
-		vecType<T, P> const & z, U c);
+	template<length_t L, typename T, typename U, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, U, P> associatedMax(
+		vecType<L, T, P> const& x, U a,
+		vecType<L, T, P> const& y, U b,
+		vecType<L, T, P> const& z, U c);
 
 	/// Maximum comparison between 4 variables and returns 4 associated variable values
 	/// @see gtx_associated_min_max
@@ -175,30 +175,30 @@ namespace glm
 
 	/// Maximum comparison between 4 variables and returns 4 associated variable values
 	/// @see gtx_associated_min_max
-	template<typename T, typename U, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<U, P> associatedMax(
-		vecType<T, P> const & x, vecType<U, P> const & a,
-		vecType<T, P> const & y, vecType<U, P> const & b,
-		vecType<T, P> const & z, vecType<U, P> const & c,
-		vecType<T, P> const & w, vecType<U, P> const & d);
+	template<length_t L, typename T, typename U, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, U, P> associatedMax(
+		vecType<L, T, P> const& x, vecType<L, U, P> const & a,
+		vecType<L, T, P> const& y, vecType<L, U, P> const & b,
+		vecType<L, T, P> const& z, vecType<L, U, P> const & c,
+		vecType<L, T, P> const& w, vecType<L, U, P> const & d);
 
 	/// Maximum comparison between 4 variables and returns 4 associated variable values
 	/// @see gtx_associated_min_max
-	template<typename T, typename U, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<U, P> associatedMax(
-		T x, vecType<U, P> const & a,
-		T y, vecType<U, P> const & b,
-		T z, vecType<U, P> const & c,
-		T w, vecType<U, P> const & d);
+	template<length_t L, typename T, typename U, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, U, P> associatedMax(
+		T x, vecType<L, U, P> const & a,
+		T y, vecType<L, U, P> const & b,
+		T z, vecType<L, U, P> const & c,
+		T w, vecType<L, U, P> const & d);
 
 	/// Maximum comparison between 4 variables and returns 4 associated variable values
 	/// @see gtx_associated_min_max
-	template<typename T, typename U, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<U, P> associatedMax(
-		vecType<T, P> const & x, U a,
-		vecType<T, P> const & y, U b,
-		vecType<T, P> const & z, U c,
-		vecType<T, P> const & w, U d);
+	template<length_t L, typename T, typename U, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, U, P> associatedMax(
+		vecType<L, T, P> const& x, U a,
+		vecType<L, T, P> const& y, U b,
+		vecType<L, T, P> const& z, U c,
+		vecType<L, T, P> const& w, U d);
 
 	/// @}
 } //namespace glm
diff --git a/glm/gtx/associated_min_max.inl b/glm/gtx/associated_min_max.inl
index 6a57d480..23a7fffd 100644
--- a/glm/gtx/associated_min_max.inl
+++ b/glm/gtx/associated_min_max.inl
@@ -10,40 +10,40 @@ GLM_FUNC_QUALIFIER U associatedMin(T x, U a, T y, U b)
 	return x < y ? a : b;
 }
 
-template<typename T, typename U, precision P, template <typename, precision> class vecType>
-GLM_FUNC_QUALIFIER tvec2<U, P> associatedMin
+template<length_t L, typename T, typename U, precision P, template<length_t, typename, precision> class vecType>
+GLM_FUNC_QUALIFIER vec<2, U, P> associatedMin
 (
-	vecType<T, P> const & x, vecType<U, P> const & a,
-	vecType<T, P> const & y, vecType<U, P> const & b
+	vecType<L, T, P> const& x, vecType<L, U, P> const & a,
+	vecType<L, T, P> const& y, vecType<L, U, P> const & b
 )
 {
-	vecType<U, P> Result(uninitialize);
+	vecType<L, U, P> Result(uninitialize);
 	for(length_t i = 0, n = Result.length(); i < n; ++i)
 		Result[i] = x[i] < y[i] ? a[i] : b[i];
 	return Result;
 }
 
-template<typename T, typename U, precision P, template <typename, precision> class vecType>
-GLM_FUNC_QUALIFIER vecType<U, P> associatedMin
+template<length_t L, typename T, typename U, precision P, template<length_t, typename, precision> class vecType>
+GLM_FUNC_QUALIFIER vecType<L, U, P> associatedMin
 (
-	T x, const vecType<U, P>& a,
-	T y, const vecType<U, P>& b
+	T x, const vecType<L, U, P>& a,
+	T y, const vecType<L, U, P>& b
 )
 {
-	vecType<U, P> Result(uninitialize);
+	vecType<L, U, P> Result(uninitialize);
 	for(length_t i = 0, n = Result.length(); i < n; ++i)
 		Result[i] = x < y ? a[i] : b[i];
 	return Result;
 }
 
-template<typename T, typename U, precision P, template <typename, precision> class vecType>
-GLM_FUNC_QUALIFIER vecType<U, P> associatedMin
+template<length_t L, typename T, typename U, precision P, template<length_t, typename, precision> class vecType>
+GLM_FUNC_QUALIFIER vecType<L, U, P> associatedMin
 (
-	vecType<T, P> const & x, U a,
-	vecType<T, P> const & y, U b
+	vecType<L, T, P> const& x, U a,
+	vecType<L, T, P> const& y, U b
 )
 {
-	vecType<U, P> Result(uninitialize);
+	vecType<L, U, P> Result(uninitialize);
 	for(length_t i = 0, n = Result.length(); i < n; ++i)
 		Result[i] = x[i] < y[i] ? a : b;
 	return Result;
@@ -62,15 +62,15 @@ GLM_FUNC_QUALIFIER U associatedMin
 	return Result;
 }
 
-template<typename T, typename U, precision P, template <typename, precision> class vecType>
-GLM_FUNC_QUALIFIER vecType<U, P> associatedMin
+template<length_t L, typename T, typename U, precision P, template<length_t, typename, precision> class vecType>
+GLM_FUNC_QUALIFIER vecType<L, U, P> associatedMin
 (
-	vecType<T, P> const & x, vecType<U, P> const & a,
-	vecType<T, P> const & y, vecType<U, P> const & b,
-	vecType<T, P> const & z, vecType<U, P> const & c
+	vecType<L, T, P> const& x, vecType<L, U, P> const & a,
+	vecType<L, T, P> const& y, vecType<L, U, P> const & b,
+	vecType<L, T, P> const& z, vecType<L, U, P> const & c
 )
 {
-	vecType<U, P> Result(uninitialize);
+	vecType<L, U, P> Result(uninitialize);
 	for(length_t i = 0, n = Result.length(); i < n; ++i)
 		Result[i] = x[i] < y[i] ? (x[i] < z[i] ? a[i] : c[i]) : (y[i] < z[i] ? b[i] : c[i]);
 	return Result;
@@ -95,16 +95,16 @@ GLM_FUNC_QUALIFIER U associatedMin
 }
 
 // Min comparison between 4 variables
-template<typename T, typename U, precision P, template <typename, precision> class vecType>
-GLM_FUNC_QUALIFIER vecType<U, P> associatedMin
+template<length_t L, typename T, typename U, precision P, template<length_t, typename, precision> class vecType>
+GLM_FUNC_QUALIFIER vecType<L, U, P> associatedMin
 (
-	vecType<T, P> const & x, vecType<U, P> const & a,
-	vecType<T, P> const & y, vecType<U, P> const & b,
-	vecType<T, P> const & z, vecType<U, P> const & c,
-	vecType<T, P> const & w, vecType<U, P> const & d
+	vecType<L, T, P> const& x, vecType<L, U, P> const & a,
+	vecType<L, T, P> const& y, vecType<L, U, P> const & b,
+	vecType<L, T, P> const& z, vecType<L, U, P> const & c,
+	vecType<L, T, P> const& w, vecType<L, U, P> const & d
 )
 {
-	vecType<U, P> Result(uninitialize);
+	vecType<L, U, P> Result(uninitialize);
 	for(length_t i = 0, n = Result.length(); i < n; ++i)
 	{
 		T Test1 = min(x[i], y[i]);
@@ -117,19 +117,19 @@ GLM_FUNC_QUALIFIER vecType<U, P> associatedMin
 }
 
 // Min comparison between 4 variables
-template<typename T, typename U, precision P, template <typename, precision> class vecType>
-GLM_FUNC_QUALIFIER vecType<U, P> associatedMin
+template<length_t L, typename T, typename U, precision P, template<length_t, typename, precision> class vecType>
+GLM_FUNC_QUALIFIER vecType<L, U, P> associatedMin
 (
-	T x, vecType<U, P> const & a,
-	T y, vecType<U, P> const & b,
-	T z, vecType<U, P> const & c,
-	T w, vecType<U, P> const & d
+	T x, vecType<L, U, P> const & a,
+	T y, vecType<L, U, P> const & b,
+	T z, vecType<L, U, P> const & c,
+	T w, vecType<L, U, P> const & d
 )
 {
 	T Test1 = min(x, y);
 	T Test2 = min(z, w);
 
-	vecType<U, P> Result(uninitialize);
+	vecType<L, U, P> Result(uninitialize);
 	for(length_t i = 0, n = Result.length(); i < n; ++i)
 	{
 		U Result1 = x < y ? a[i] : b[i];
@@ -140,16 +140,16 @@ GLM_FUNC_QUALIFIER vecType<U, P> associatedMin
 }
 
 // Min comparison between 4 variables
-template<typename T, typename U, precision P, template <typename, precision> class vecType>
-GLM_FUNC_QUALIFIER vecType<U, P> associatedMin
+template<length_t L, typename T, typename U, precision P, template<length_t, typename, precision> class vecType>
+GLM_FUNC_QUALIFIER vecType<L, U, P> associatedMin
 (
-	vecType<T, P> const & x, U a,
-	vecType<T, P> const & y, U b,
-	vecType<T, P> const & z, U c,
-	vecType<T, P> const & w, U d
+	vecType<L, T, P> const& x, U a,
+	vecType<L, T, P> const& y, U b,
+	vecType<L, T, P> const& z, U c,
+	vecType<L, T, P> const& w, U d
 )
 {
-	vecType<U, P> Result(uninitialize);
+	vecType<L, U, P> Result(uninitialize);
 	for(length_t i = 0, n = Result.length(); i < n; ++i)
 	{
 		T Test1 = min(x[i], y[i]);
@@ -169,42 +169,42 @@ GLM_FUNC_QUALIFIER U associatedMax(T x, U a, T y, U b)
 }
 
 // Max comparison between 2 variables
-template<typename T, typename U, precision P, template <typename, precision> class vecType>
-GLM_FUNC_QUALIFIER tvec2<U, P> associatedMax
+template<length_t L, typename T, typename U, precision P, template<length_t, typename, precision> class vecType>
+GLM_FUNC_QUALIFIER vec<2, U, P> associatedMax
 (
-	vecType<T, P> const & x, vecType<U, P> const & a,
-	vecType<T, P> const & y, vecType<U, P> const & b
+	vecType<L, T, P> const& x, vecType<L, U, P> const & a,
+	vecType<L, T, P> const& y, vecType<L, U, P> const & b
 )
 {
-	vecType<U, P> Result(uninitialize);
+	vecType<L, U, P> Result(uninitialize);
 	for(length_t i = 0, n = Result.length(); i < n; ++i)
 		Result[i] = x[i] > y[i] ? a[i] : b[i];
 	return Result;
 }
 
 // Max comparison between 2 variables
-template<typename T, typename U, precision P, template <typename, precision> class vecType>
-GLM_FUNC_QUALIFIER vecType<T, P> associatedMax
+template<length_t L, typename T, typename U, precision P, template<length_t, typename, precision> class vecType>
+GLM_FUNC_QUALIFIER vecType<L, T, P> associatedMax
 (
-	T x, vecType<U, P> const & a,
-	T y, vecType<U, P> const & b
+	T x, vecType<L, U, P> const & a,
+	T y, vecType<L, U, P> const & b
 )
 {
-	vecType<U, P> Result(uninitialize);
+	vecType<L, U, P> Result(uninitialize);
 	for(length_t i = 0, n = Result.length(); i < n; ++i)
 		Result[i] = x > y ? a[i] : b[i];
 	return Result;
 }
 
 // Max comparison between 2 variables
-template<typename T, typename U, precision P, template <typename, precision> class vecType>
-GLM_FUNC_QUALIFIER vecType<U, P> associatedMax
+template<length_t L, typename T, typename U, precision P, template<length_t, typename, precision> class vecType>
+GLM_FUNC_QUALIFIER vecType<L, U, P> associatedMax
 (
-	vecType<T, P> const & x, U a,
-	vecType<T, P> const & y, U b
+	vecType<L, T, P> const& x, U a,
+	vecType<L, T, P> const& y, U b
 )
 {
-	vecType<T, P> Result(uninitialize);
+	vecType<L, T, P> Result(uninitialize);
 	for(length_t i = 0, n = Result.length(); i < n; ++i)
 		Result[i] = x[i] > y[i] ? a : b;
 	return Result;
@@ -224,45 +224,45 @@ GLM_FUNC_QUALIFIER U associatedMax
 }
 
 // Max comparison between 3 variables
-template<typename T, typename U, precision P, template <typename, precision> class vecType>
-GLM_FUNC_QUALIFIER vecType<U, P> associatedMax
+template<length_t L, typename T, typename U, precision P, template<length_t, typename, precision> class vecType>
+GLM_FUNC_QUALIFIER vecType<L, U, P> associatedMax
 (
-	vecType<T, P> const & x, vecType<U, P> const & a,
-	vecType<T, P> const & y, vecType<U, P> const & b,
-	vecType<T, P> const & z, vecType<U, P> const & c
+	vecType<L, T, P> const& x, vecType<L, U, P> const & a,
+	vecType<L, T, P> const& y, vecType<L, U, P> const & b,
+	vecType<L, T, P> const& z, vecType<L, U, P> const & c
 )
 {
-	vecType<U, P> Result(uninitialize);
+	vecType<L, U, P> Result(uninitialize);
 	for(length_t i = 0, n = Result.length(); i < n; ++i)
 		Result[i] = x[i] > y[i] ? (x[i] > z[i] ? a[i] : c[i]) : (y[i] > z[i] ? b[i] : c[i]);
 	return Result;
 }
 
 // Max comparison between 3 variables
-template<typename T, typename U, precision P, template <typename, precision> class vecType>
-GLM_FUNC_QUALIFIER vecType<T, P> associatedMax
+template<length_t L, typename T, typename U, precision P, template<length_t, typename, precision> class vecType>
+GLM_FUNC_QUALIFIER vecType<L, T, P> associatedMax
 (
-	T x, vecType<U, P> const & a,
-	T y, vecType<U, P> const & b,
-	T z, vecType<U, P> const & c
+	T x, vecType<L, U, P> const & a,
+	T y, vecType<L, U, P> const & b,
+	T z, vecType<L, U, P> const & c
 )
 {
-	vecType<U, P> Result(uninitialize);
+	vecType<L, U, P> Result(uninitialize);
 	for(length_t i = 0, n = Result.length(); i < n; ++i)
 		Result[i] = x > y ? (x > z ? a[i] : c[i]) : (y > z ? b[i] : c[i]);
 	return Result;
 }
 
 // Max comparison between 3 variables
-template<typename T, typename U, precision P, template <typename, precision> class vecType>
-GLM_FUNC_QUALIFIER vecType<U, P> associatedMax
+template<length_t L, typename T, typename U, precision P, template<length_t, typename, precision> class vecType>
+GLM_FUNC_QUALIFIER vecType<L, U, P> associatedMax
 (
-	vecType<T, P> const & x, U a,
-	vecType<T, P> const & y, U b,
-	vecType<T, P> const & z, U c
+	vecType<L, T, P> const& x, U a,
+	vecType<L, T, P> const& y, U b,
+	vecType<L, T, P> const& z, U c
 )
 {
-	vecType<T, P> Result(uninitialize);
+	vecType<L, T, P> Result(uninitialize);
 	for(length_t i = 0, n = Result.length(); i < n; ++i)
 		Result[i] = x[i] > y[i] ? (x[i] > z[i] ? a : c) : (y[i] > z[i] ? b : c);
 	return Result;
@@ -287,16 +287,16 @@ GLM_FUNC_QUALIFIER U associatedMax
 }
 
 // Max comparison between 4 variables
-template<typename T, typename U, precision P, template <typename, precision> class vecType>
-GLM_FUNC_QUALIFIER vecType<U, P> associatedMax
+template<length_t L, typename T, typename U, precision P, template<length_t, typename, precision> class vecType>
+GLM_FUNC_QUALIFIER vecType<L, U, P> associatedMax
 (
-	vecType<T, P> const & x, vecType<U, P> const & a,
-	vecType<T, P> const & y, vecType<U, P> const & b,
-	vecType<T, P> const & z, vecType<U, P> const & c,
-	vecType<T, P> const & w, vecType<U, P> const & d
+	vecType<L, T, P> const& x, vecType<L, U, P> const & a,
+	vecType<L, T, P> const& y, vecType<L, U, P> const & b,
+	vecType<L, T, P> const& z, vecType<L, U, P> const & c,
+	vecType<L, T, P> const& w, vecType<L, U, P> const & d
 )
 {
-	vecType<U, P> Result(uninitialize);
+	vecType<L, U, P> Result(uninitialize);
 	for(length_t i = 0, n = Result.length(); i < n; ++i)
 	{
 		T Test1 = max(x[i], y[i]);
@@ -309,19 +309,19 @@ GLM_FUNC_QUALIFIER vecType<U, P> associatedMax
 }
 
 // Max comparison between 4 variables
-template<typename T, typename U, precision P, template <typename, precision> class vecType>
-GLM_FUNC_QUALIFIER vecType<U, P> associatedMax
+template<length_t L, typename T, typename U, precision P, template<length_t, typename, precision> class vecType>
+GLM_FUNC_QUALIFIER vecType<L, U, P> associatedMax
 (
-	T x, vecType<U, P> const & a,
-	T y, vecType<U, P> const & b,
-	T z, vecType<U, P> const & c,
-	T w, vecType<U, P> const & d
+	T x, vecType<L, U, P> const & a,
+	T y, vecType<L, U, P> const & b,
+	T z, vecType<L, U, P> const & c,
+	T w, vecType<L, U, P> const & d
 )
 {
 	T Test1 = max(x, y);
 	T Test2 = max(z, w);
 
-	vecType<U, P> Result(uninitialize);
+	vecType<L, U, P> Result(uninitialize);
 	for(length_t i = 0, n = Result.length(); i < n; ++i)
 	{
 		U Result1 = x > y ? a[i] : b[i];
@@ -332,16 +332,16 @@ GLM_FUNC_QUALIFIER vecType<U, P> associatedMax
 }
 
 // Max comparison between 4 variables
-template<typename T, typename U, precision P, template <typename, precision> class vecType>
-GLM_FUNC_QUALIFIER vecType<U, P> associatedMax
+template<length_t L, typename T, typename U, precision P, template<length_t, typename, precision> class vecType>
+GLM_FUNC_QUALIFIER vecType<L, U, P> associatedMax
 (
-	vecType<T, P> const & x, U a,
-	vecType<T, P> const & y, U b,
-	vecType<T, P> const & z, U c,
-	vecType<T, P> const & w, U d
+	vecType<L, T, P> const& x, U a,
+	vecType<L, T, P> const& y, U b,
+	vecType<L, T, P> const& z, U c,
+	vecType<L, T, P> const& w, U d
 )
 {
-	vecType<U, P> Result(uninitialize);
+	vecType<L, U, P> Result(uninitialize);
 	for(length_t i = 0, n = Result.length(); i < n; ++i)
 	{
 		T Test1 = max(x[i], y[i]);
diff --git a/glm/gtx/bit.hpp b/glm/gtx/bit.hpp
index 66f22f59..15bfe5d6 100644
--- a/glm/gtx/bit.hpp
+++ b/glm/gtx/bit.hpp
@@ -29,25 +29,25 @@ namespace glm
 	/// @{
 
 	/// @see gtx_bit
-	template <typename genIUType>
+	template<typename genIUType>
 	GLM_FUNC_DECL genIUType highestBitValue(genIUType Value);
 
 	/// @see gtx_bit
-	template <typename genIUType>
+	template<typename genIUType>
 	GLM_FUNC_DECL genIUType lowestBitValue(genIUType Value);
 
 	/// Find the highest bit set to 1 in a integer variable and return its value.
 	///
 	/// @see gtx_bit
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> highestBitValue(vecType<T, P> const & value);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, T, P> highestBitValue(vecType<L, T, P> const & value);
 
 	/// Return the power of two number which value is just higher the input value.
 	/// Deprecated, use ceilPowerOfTwo from GTC_round instead
 	///
 	/// @see gtc_round
 	/// @see gtx_bit
-	template <typename genIUType>
+	template<typename genIUType>
 	GLM_DEPRECATED GLM_FUNC_DECL genIUType powerOfTwoAbove(genIUType Value);
 
 	/// Return the power of two number which value is just higher the input value.
@@ -55,15 +55,15 @@ namespace glm
 	///
 	/// @see gtc_round
 	/// @see gtx_bit
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_DEPRECATED GLM_FUNC_DECL vecType<T, P> powerOfTwoAbove(vecType<T, P> const & value);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_DEPRECATED GLM_FUNC_DECL vecType<L, T, P> powerOfTwoAbove(vecType<L, T, P> const & value);
 
 	/// Return the power of two number which value is just lower the input value.
 	/// Deprecated, use floorPowerOfTwo from GTC_round instead
 	///
 	/// @see gtc_round
 	/// @see gtx_bit
-	template <typename genIUType>
+	template<typename genIUType>
 	GLM_DEPRECATED GLM_FUNC_DECL genIUType powerOfTwoBelow(genIUType Value);
 
 	/// Return the power of two number which value is just lower the input value.
@@ -71,15 +71,15 @@ namespace glm
 	///
 	/// @see gtc_round
 	/// @see gtx_bit
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_DEPRECATED GLM_FUNC_DECL vecType<T, P> powerOfTwoBelow(vecType<T, P> const & value);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_DEPRECATED GLM_FUNC_DECL vecType<L, T, P> powerOfTwoBelow(vecType<L, T, P> const & value);
 
 	/// Return the power of two number which value is the closet to the input value.
 	/// Deprecated, use roundPowerOfTwo from GTC_round instead
 	///
 	/// @see gtc_round
 	/// @see gtx_bit
-	template <typename genIUType>
+	template<typename genIUType>
 	GLM_DEPRECATED GLM_FUNC_DECL genIUType powerOfTwoNearest(genIUType Value);
 
 	/// Return the power of two number which value is the closet to the input value.
@@ -87,8 +87,8 @@ namespace glm
 	///
 	/// @see gtc_round
 	/// @see gtx_bit
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_DEPRECATED GLM_FUNC_DECL vecType<T, P> powerOfTwoNearest(vecType<T, P> const & value);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_DEPRECATED GLM_FUNC_DECL vecType<L, T, P> powerOfTwoNearest(vecType<L, T, P> const & value);
 
 	/// @}
 } //namespace glm
diff --git a/glm/gtx/bit.inl b/glm/gtx/bit.inl
index 10d5f7fa..ff7530c4 100644
--- a/glm/gtx/bit.inl
+++ b/glm/gtx/bit.inl
@@ -6,7 +6,7 @@ namespace glm
 	///////////////////
 	// highestBitValue
 
-	template <typename genIUType>
+	template<typename genIUType>
 	GLM_FUNC_QUALIFIER genIUType highestBitValue(genIUType Value)
 	{
 		genIUType tmp = Value;
@@ -19,61 +19,61 @@ namespace glm
 		return result;
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> highestBitValue(vecType<T, P> const & v)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> highestBitValue(vecType<L, T, P> const & v)
 	{
-		return detail::functor1<T, T, P, vecType>::call(highestBitValue, v);
+		return detail::functor1<L, T, T, P>::call(highestBitValue, v);
 	}
 
 	///////////////////
 	// lowestBitValue
 
-	template <typename genIUType>
+	template<typename genIUType>
 	GLM_FUNC_QUALIFIER genIUType lowestBitValue(genIUType Value)
 	{
 		return (Value & (~Value + 1));
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> lowestBitValue(vecType<T, P> const & v)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> lowestBitValue(vecType<L, T, P> const & v)
 	{
-		return detail::functor1<T, T, P, vecType>::call(lowestBitValue, v);
+		return detail::functor1<L, T, T, P>::call(lowestBitValue, v);
 	}
 
 	///////////////////
 	// powerOfTwoAbove
 
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER genType powerOfTwoAbove(genType value)
 	{
 		return isPowerOfTwo(value) ? value : highestBitValue(value) << 1;
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> powerOfTwoAbove(vecType<T, P> const & v)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> powerOfTwoAbove(vecType<L, T, P> const & v)
 	{
-		return detail::functor1<T, T, P, vecType>::call(powerOfTwoAbove, v);
+		return detail::functor1<L, T, T, P>::call(powerOfTwoAbove, v);
 	}
 
 	///////////////////
 	// powerOfTwoBelow
 
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER genType powerOfTwoBelow(genType value)
 	{
 		return isPowerOfTwo(value) ? value : highestBitValue(value);
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> powerOfTwoBelow(vecType<T, P> const & v)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> powerOfTwoBelow(vecType<L, T, P> const & v)
 	{
-		return detail::functor1<T, T, P, vecType>::call(powerOfTwoBelow, v);
+		return detail::functor1<L, T, T, P>::call(powerOfTwoBelow, v);
 	}
 
 	/////////////////////
 	// powerOfTwoNearest
 
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER genType powerOfTwoNearest(genType value)
 	{
 		if(isPowerOfTwo(value))
@@ -84,10 +84,10 @@ namespace glm
 		return (next - value) < (value - prev) ? next : prev;
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> powerOfTwoNearest(vecType<T, P> const & v)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> powerOfTwoNearest(vecType<L, T, P> const & v)
 	{
-		return detail::functor1<T, T, P, vecType>::call(powerOfTwoNearest, v);
+		return detail::functor1<L, T, T, P>::call(powerOfTwoNearest, v);
 	}
 
 }//namespace glm
diff --git a/glm/gtx/closest_point.hpp b/glm/gtx/closest_point.hpp
index 8972cea2..a8433360 100644
--- a/glm/gtx/closest_point.hpp
+++ b/glm/gtx/closest_point.hpp
@@ -30,18 +30,18 @@ namespace glm
 
 	/// Find the point on a straight line which is the closet of a point. 
 	/// @see gtx_closest_point
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> closestPointOnLine(
-		tvec3<T, P> const & point,
-		tvec3<T, P> const & a, 
-		tvec3<T, P> const & b);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<3, T, P> closestPointOnLine(
+		vec<3, T, P> const & point,
+		vec<3, T, P> const & a, 
+		vec<3, T, P> const & b);
 	
 	/// 2d lines work as well	
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec2<T, P> closestPointOnLine(
-		tvec2<T, P> const & point,
-		tvec2<T, P> const & a, 
-		tvec2<T, P> const & b);	
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<2, T, P> closestPointOnLine(
+		vec<2, T, P> const & point,
+		vec<2, T, P> const & a, 
+		vec<2, T, P> const & b);	
 
 	/// @}
 }// namespace glm
diff --git a/glm/gtx/closest_point.inl b/glm/gtx/closest_point.inl
index 5c6a8793..fdbc9373 100644
--- a/glm/gtx/closest_point.inl
+++ b/glm/gtx/closest_point.inl
@@ -3,17 +3,17 @@
 
 namespace glm
 {
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> closestPointOnLine
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> closestPointOnLine
 	(
-		tvec3<T, P> const & point,
-		tvec3<T, P> const & a,
-		tvec3<T, P> const & b
+		vec<3, T, P> const & point,
+		vec<3, T, P> const & a,
+		vec<3, T, P> const & b
 	)
 	{
 		T LineLength = distance(a, b);
-		tvec3<T, P> Vector = point - a;
-		tvec3<T, P> LineDirection = (b - a) / LineLength;
+		vec<3, T, P> Vector = point - a;
+		vec<3, T, P> LineDirection = (b - a) / LineLength;
 
 		// Project Vector to LineDirection to get the distance of point from a
 		T Distance = dot(Vector, LineDirection);
@@ -23,17 +23,17 @@ namespace glm
 		return a + LineDirection * Distance;
 	}
 	
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P> closestPointOnLine
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<2, T, P> closestPointOnLine
 	(
-		tvec2<T, P> const & point,
-		tvec2<T, P> const & a,
-		tvec2<T, P> const & b
+		vec<2, T, P> const & point,
+		vec<2, T, P> const & a,
+		vec<2, T, P> const & b
 	)
 	{
 		T LineLength = distance(a, b);
-		tvec2<T, P> Vector = point - a;
-		tvec2<T, P> LineDirection = (b - a) / LineLength;
+		vec<2, T, P> Vector = point - a;
+		vec<2, T, P> LineDirection = (b - a) / LineLength;
 
 		// Project Vector to LineDirection to get the distance of point from a
 		T Distance = dot(Vector, LineDirection);
diff --git a/glm/gtx/color_encoding.hpp b/glm/gtx/color_encoding.hpp
index 9537ecd1..0994e283 100644
--- a/glm/gtx/color_encoding.hpp
+++ b/glm/gtx/color_encoding.hpp
@@ -29,20 +29,20 @@ namespace glm
 	/// @{
 
 	/// Convert a linear sRGB color to D65 YUV.
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> convertLinearSRGBToD65XYZ(tvec3<T, P> const& ColorLinearSRGB);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<3, T, P> convertLinearSRGBToD65XYZ(vec<3, T, P> const& ColorLinearSRGB);
 
 	/// Convert a linear sRGB color to D50 YUV.
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> convertLinearSRGBToD50XYZ(tvec3<T, P> const& ColorLinearSRGB);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<3, T, P> convertLinearSRGBToD50XYZ(vec<3, T, P> const& ColorLinearSRGB);
 
 	/// Convert a D65 YUV color to linear sRGB.
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> convertD65XYZToLinearSRGB(tvec3<T, P> const& ColorD65XYZ);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<3, T, P> convertD65XYZToLinearSRGB(vec<3, T, P> const& ColorD65XYZ);
 
 	/// Convert a D65 YUV color to D50 YUV.
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> convertD65XYZToD50XYZ(tvec3<T, P> const& ColorD65XYZ);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<3, T, P> convertD65XYZToD50XYZ(vec<3, T, P> const& ColorD65XYZ);
 
 	/// @}
 } //namespace glm
diff --git a/glm/gtx/color_encoding.inl b/glm/gtx/color_encoding.inl
index f7210462..ad82dc52 100644
--- a/glm/gtx/color_encoding.inl
+++ b/glm/gtx/color_encoding.inl
@@ -3,42 +3,42 @@
 
 namespace glm
 {
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> convertLinearSRGBToD65XYZ(tvec3<T, P> const& ColorLinearSRGB)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> convertLinearSRGBToD65XYZ(vec<3, T, P> const& ColorLinearSRGB)
 	{
-		tvec3<T, P> const M(0.490f, 0.17697f, 0.2f);
-		tvec3<T, P> const N(0.31f,  0.8124f, 0.01063f);
-		tvec3<T, P> const O(0.490f, 0.01f, 0.99f);
+		vec<3, T, P> const M(0.490f, 0.17697f, 0.2f);
+		vec<3, T, P> const N(0.31f,  0.8124f, 0.01063f);
+		vec<3, T, P> const O(0.490f, 0.01f, 0.99f);
 
 		return (M * ColorLinearSRGB + N * ColorLinearSRGB + O * ColorLinearSRGB) * static_cast<T>(5.650675255693055f);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> convertLinearSRGBToD50XYZ(tvec3<T, P> const& ColorLinearSRGB)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> convertLinearSRGBToD50XYZ(vec<3, T, P> const& ColorLinearSRGB)
 	{
-		tvec3<T, P> const M(0.436030342570117f, 0.222438466210245f, 0.013897440074263f);
-		tvec3<T, P> const N(0.385101860087134f, 0.716942745571917f, 0.097076381494207f);
-		tvec3<T, P> const O(0.143067806654203f, 0.060618777416563f, 0.713926257896652f);
+		vec<3, T, P> const M(0.436030342570117f, 0.222438466210245f, 0.013897440074263f);
+		vec<3, T, P> const N(0.385101860087134f, 0.716942745571917f, 0.097076381494207f);
+		vec<3, T, P> const O(0.143067806654203f, 0.060618777416563f, 0.713926257896652f);
 
 		return M * ColorLinearSRGB + N * ColorLinearSRGB + O * ColorLinearSRGB;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> convertD65XYZToLinearSRGB(tvec3<T, P> const& ColorD65XYZ)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> convertD65XYZToLinearSRGB(vec<3, T, P> const& ColorD65XYZ)
 	{
-		tvec3<T, P> const M(0.41847f, -0.091169f, 0.0009209f);
-		tvec3<T, P> const N(-0.15866f, 0.25243f, 0.015708f);
-		tvec3<T, P> const O(0.0009209f, -0.0025498f, 0.1786f);
+		vec<3, T, P> const M(0.41847f, -0.091169f, 0.0009209f);
+		vec<3, T, P> const N(-0.15866f, 0.25243f, 0.015708f);
+		vec<3, T, P> const O(0.0009209f, -0.0025498f, 0.1786f);
 
 		return M * ColorD65XYZ + N * ColorD65XYZ + O * ColorD65XYZ;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> convertD65XYZToD50XYZ(tvec3<T, P> const& ColorD65XYZ)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> convertD65XYZToD50XYZ(vec<3, T, P> const& ColorD65XYZ)
 	{
-		tvec3<T, P> const M(+1.047844353856414f, +0.029549007606644f, -0.009250984365223f);
-		tvec3<T, P> const N(+0.022898981050086f, +0.990508028941971f, +0.015072338237051f);
-		tvec3<T, P> const O(-0.050206647741605f, -0.017074711360960f, +0.751717835079977f);
+		vec<3, T, P> const M(+1.047844353856414f, +0.029549007606644f, -0.009250984365223f);
+		vec<3, T, P> const N(+0.022898981050086f, +0.990508028941971f, +0.015072338237051f);
+		vec<3, T, P> const O(-0.050206647741605f, -0.017074711360960f, +0.751717835079977f);
 
 		return M * ColorD65XYZ + N * ColorD65XYZ + O * ColorD65XYZ;
 	}
diff --git a/glm/gtx/color_space.hpp b/glm/gtx/color_space.hpp
index 4260ca0d..04ff13e6 100644
--- a/glm/gtx/color_space.hpp
+++ b/glm/gtx/color_space.hpp
@@ -30,41 +30,41 @@ namespace glm
 
 	/// Converts a color from HSV color space to its color in RGB color space.
 	/// @see gtx_color_space
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> rgbColor(
-		tvec3<T, P> const & hsvValue);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<3, T, P> rgbColor(
+		vec<3, T, P> const & hsvValue);
 
 	/// Converts a color from RGB color space to its color in HSV color space.
 	/// @see gtx_color_space
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> hsvColor(
-		tvec3<T, P> const & rgbValue);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<3, T, P> hsvColor(
+		vec<3, T, P> const & rgbValue);
 		
 	/// Build a saturation matrix.
 	/// @see gtx_color_space
-	template <typename T>
-	GLM_FUNC_DECL tmat4x4<T, defaultp> saturation(
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> saturation(
 		T const s);
 
 	/// Modify the saturation of a color.
 	/// @see gtx_color_space
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> saturation(
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<3, T, P> saturation(
 		T const s,
-		tvec3<T, P> const & color);
+		vec<3, T, P> const & color);
 		
 	/// Modify the saturation of a color.
 	/// @see gtx_color_space
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec4<T, P> saturation(
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<4, T, P> saturation(
 		T const s,
-		tvec4<T, P> const & color);
+		vec<4, T, P> const & color);
 		
 	/// Compute color luminosity associating ratios (0.33, 0.59, 0.11) to RGB canals.
 	/// @see gtx_color_space
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_DECL T luminosity(
-		tvec3<T, P> const & color);
+		vec<3, T, P> const & color);
 
 	/// @}
 }//namespace glm
diff --git a/glm/gtx/color_space.inl b/glm/gtx/color_space.inl
index 11e0ac83..9f5572bf 100644
--- a/glm/gtx/color_space.inl
+++ b/glm/gtx/color_space.inl
@@ -3,15 +3,15 @@
 
 namespace glm
 {
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> rgbColor(const tvec3<T, P>& hsvColor)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> rgbColor(const vec<3, T, P>& hsvColor)
 	{
-		tvec3<T, P> hsv = hsvColor;
-		tvec3<T, P> rgbColor;
+		vec<3, T, P> hsv = hsvColor;
+		vec<3, T, P> rgbColor;
 
 		if(hsv.y == static_cast<T>(0))
 			// achromatic (grey)
-			rgbColor = tvec3<T, P>(hsv.z);
+			rgbColor = vec<3, T, P>(hsv.z);
 		else
 		{
 			T sector = floor(hsv.x * (T(1) / T(60)));
@@ -60,10 +60,10 @@ namespace glm
 		return rgbColor;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> hsvColor(const tvec3<T, P>& rgbColor)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> hsvColor(const vec<3, T, P>& rgbColor)
 	{
-		tvec3<T, P> hsv = rgbColor;
+		vec<3, T, P> hsv = rgbColor;
 		float Min   = min(min(rgbColor.r, rgbColor.g), rgbColor.b);
 		float Max   = max(max(rgbColor.r, rgbColor.g), rgbColor.b);
 		float Delta = Max - Min;
@@ -100,16 +100,16 @@ namespace glm
 		return hsv;
 	}
 
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> saturation(T const s)
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> saturation(T const s)
 	{
-		tvec3<T, defaultp> rgbw = tvec3<T, defaultp>(T(0.2126), T(0.7152), T(0.0722));
+		vec<3, T, defaultp> rgbw = vec<3, T, defaultp>(T(0.2126), T(0.7152), T(0.0722));
 
 		T col0 = (T(1) - s) * rgbw.r;
 		T col1 = (T(1) - s) * rgbw.g;
 		T col2 = (T(1) - s) * rgbw.b;
 
-		tmat4x4<T, defaultp> result(T(1));
+		mat<4, 4, T, defaultp> result(T(1));
 		result[0][0] = col0 + s;
 		result[0][1] = col0;
 		result[0][2] = col0;
@@ -122,22 +122,22 @@ namespace glm
 		return result;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> saturation(const T s, const tvec3<T, P>& color)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> saturation(const T s, const vec<3, T, P>& color)
 	{
-		return tvec3<T, P>(saturation(s) * tvec4<T, P>(color, T(0)));
+		return vec<3, T, P>(saturation(s) * vec<4, T, P>(color, T(0)));
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> saturation(const T s, const tvec4<T, P>& color)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, T, P> saturation(const T s, const vec<4, T, P>& color)
 	{
 		return saturation(s) * color;
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER T luminosity(const tvec3<T, P>& color)
+	template<typename T, precision P> 
+	GLM_FUNC_QUALIFIER T luminosity(const vec<3, T, P>& color)
 	{
-		const tvec3<T, P> tmp = tvec3<T, P>(0.33, 0.59, 0.11);
+		const vec<3, T, P> tmp = vec<3, T, P>(0.33, 0.59, 0.11);
 		return dot(color, tmp);
 	}
 }//namespace glm
diff --git a/glm/gtx/color_space_YCoCg.hpp b/glm/gtx/color_space_YCoCg.hpp
index ebe79744..0ac1dc36 100644
--- a/glm/gtx/color_space_YCoCg.hpp
+++ b/glm/gtx/color_space_YCoCg.hpp
@@ -30,29 +30,29 @@ namespace glm
 
 	/// Convert a color from RGB color space to YCoCg color space.
 	/// @see gtx_color_space_YCoCg
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> rgb2YCoCg(
-		tvec3<T, P> const & rgbColor);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<3, T, P> rgb2YCoCg(
+		vec<3, T, P> const & rgbColor);
 
 	/// Convert a color from YCoCg color space to RGB color space.
 	/// @see gtx_color_space_YCoCg
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> YCoCg2rgb(
-		tvec3<T, P> const & YCoCgColor);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<3, T, P> YCoCg2rgb(
+		vec<3, T, P> const & YCoCgColor);
 
 	/// Convert a color from RGB color space to YCoCgR color space.
 	/// @see "YCoCg-R: A Color Space with RGB Reversibility and Low Dynamic Range"
 	/// @see gtx_color_space_YCoCg
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> rgb2YCoCgR(
-		tvec3<T, P> const & rgbColor);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<3, T, P> rgb2YCoCgR(
+		vec<3, T, P> const & rgbColor);
 
 	/// Convert a color from YCoCgR color space to RGB color space.
 	/// @see "YCoCg-R: A Color Space with RGB Reversibility and Low Dynamic Range"
 	/// @see gtx_color_space_YCoCg
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> YCoCgR2rgb(
-		tvec3<T, P> const & YCoCgColor);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<3, T, P> YCoCgR2rgb(
+		vec<3, T, P> const & YCoCgColor);
 
 	/// @}
 }//namespace glm
diff --git a/glm/gtx/color_space_YCoCg.inl b/glm/gtx/color_space_YCoCg.inl
index bfff3519..62b04417 100644
--- a/glm/gtx/color_space_YCoCg.inl
+++ b/glm/gtx/color_space_YCoCg.inl
@@ -3,53 +3,53 @@
 
 namespace glm
 {
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> rgb2YCoCg
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> rgb2YCoCg
 	(
-		tvec3<T, P> const & rgbColor
+		vec<3, T, P> const & rgbColor
 	)
 	{
-		tvec3<T, P> result;
+		vec<3, T, P> result;
 		result.x/*Y */ =   rgbColor.r / T(4) + rgbColor.g / T(2) + rgbColor.b / T(4);
 		result.y/*Co*/ =   rgbColor.r / T(2) + rgbColor.g * T(0) - rgbColor.b / T(2);
 		result.z/*Cg*/ = - rgbColor.r / T(4) + rgbColor.g / T(2) - rgbColor.b / T(4);
 		return result;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> YCoCg2rgb
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> YCoCg2rgb
 	(
-		tvec3<T, P> const & YCoCgColor
+		vec<3, T, P> const & YCoCgColor
 	)
 	{
-		tvec3<T, P> result;
+		vec<3, T, P> result;
 		result.r = YCoCgColor.x + YCoCgColor.y - YCoCgColor.z;
 		result.g = YCoCgColor.x				   + YCoCgColor.z;
 		result.b = YCoCgColor.x - YCoCgColor.y - YCoCgColor.z;
 		return result;
 	}
 
-	template <typename T, precision P, bool isInteger>
+	template<typename T, precision P, bool isInteger>
 	class compute_YCoCgR {
 	public:
-		static GLM_FUNC_QUALIFIER tvec3<T, P> rgb2YCoCgR
+		static GLM_FUNC_QUALIFIER vec<3, T, P> rgb2YCoCgR
 		(
-			tvec3<T, P> const & rgbColor
+			vec<3, T, P> const & rgbColor
 		)
 		{
-			tvec3<T, P> result;
+			vec<3, T, P> result;
 			result.x/*Y */ = rgbColor.g * static_cast<T>(0.5) + (rgbColor.r + rgbColor.b) * static_cast<T>(0.25);
 			result.y/*Co*/ = rgbColor.r - rgbColor.b;
 			result.z/*Cg*/ = rgbColor.g - (rgbColor.r + rgbColor.b) * static_cast<T>(0.5);
 			return result;
 		}
 
-		static GLM_FUNC_QUALIFIER tvec3<T, P> YCoCgR2rgb
+		static GLM_FUNC_QUALIFIER vec<3, T, P> YCoCgR2rgb
 		(
-			tvec3<T, P> const & YCoCgRColor
+			vec<3, T, P> const & YCoCgRColor
 		)
 		{
-			tvec3<T, P> result;
+			vec<3, T, P> result;
 			T tmp = YCoCgRColor.x - (YCoCgRColor.z * static_cast<T>(0.5));
 			result.g = YCoCgRColor.z + tmp;
 			result.b = tmp - (YCoCgRColor.y * static_cast<T>(0.5));
@@ -58,15 +58,15 @@ namespace glm
 		}
 	};
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	class compute_YCoCgR<T, P, true> {
 	public:
-		static GLM_FUNC_QUALIFIER tvec3<T, P> rgb2YCoCgR
+		static GLM_FUNC_QUALIFIER vec<3, T, P> rgb2YCoCgR
 		(
-			tvec3<T, P> const & rgbColor
+			vec<3, T, P> const & rgbColor
 		)
 		{
-			tvec3<T, P> result;
+			vec<3, T, P> result;
 			result.y/*Co*/ = rgbColor.r - rgbColor.b;
 			T tmp = rgbColor.b + (result.y >> 1);
 			result.z/*Cg*/ = rgbColor.g - tmp;
@@ -74,12 +74,12 @@ namespace glm
 			return result;
 		}
 
-		static GLM_FUNC_QUALIFIER tvec3<T, P> YCoCgR2rgb
+		static GLM_FUNC_QUALIFIER vec<3, T, P> YCoCgR2rgb
 		(
-			tvec3<T, P> const & YCoCgRColor
+			vec<3, T, P> const & YCoCgRColor
 		)
 		{
-			tvec3<T, P> result;
+			vec<3, T, P> result;
 			T tmp = YCoCgRColor.x - (YCoCgRColor.z >> 1);
 			result.g = YCoCgRColor.z + tmp;
 			result.b = tmp - (YCoCgRColor.y >> 1);
@@ -88,19 +88,19 @@ namespace glm
 		}
 	};
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> rgb2YCoCgR
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> rgb2YCoCgR
 	(
-		tvec3<T, P> const & rgbColor
+		vec<3, T, P> const & rgbColor
 	)
 	{
 		return compute_YCoCgR<T, P, std::numeric_limits<T>::is_integer>::rgb2YCoCgR(rgbColor);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> YCoCgR2rgb
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> YCoCgR2rgb
 	(
-		tvec3<T, P> const & YCoCgRColor
+		vec<3, T, P> const & YCoCgRColor
 	)
 	{
 		return compute_YCoCgR<T, P, std::numeric_limits<T>::is_integer>::YCoCgR2rgb(YCoCgRColor);
diff --git a/glm/gtx/common.hpp b/glm/gtx/common.hpp
index f8185c66..f3366dd0 100644
--- a/glm/gtx/common.hpp
+++ b/glm/gtx/common.hpp
@@ -39,7 +39,7 @@ namespace glm
 	///
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/isnan.xml">GLSL isnan man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
-	template <typename genType> 
+	template<typename genType> 
 	GLM_FUNC_DECL typename genType::bool_type isdenormal(genType const & x);
 
 	/// Similar to 'mod' but with a different rounding and integer support.
@@ -47,8 +47,8 @@ namespace glm
 	/// 
 	/// @see <a href="http://stackoverflow.com/questions/7610631/glsl-mod-vs-hlsl-fmod">GLSL mod vs HLSL fmod</a>
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/mod.xml">GLSL mod man page</a>
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> fmod(vecType<T, P> const & v);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, T, P> fmod(vecType<L, T, P> const & v);
 
 	/// @}
 }//namespace glm
diff --git a/glm/gtx/common.inl b/glm/gtx/common.inl
index 6c9cb651..97b5c7d3 100644
--- a/glm/gtx/common.inl
+++ b/glm/gtx/common.inl
@@ -6,26 +6,26 @@
 namespace glm{
 namespace detail
 {
-	template <typename T, precision P, template <class, precision> class vecType, bool isFloat = true>
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType, bool isFloat = true>
 	struct compute_fmod
 	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & a, vecType<T, P> const & b)
+		GLM_FUNC_QUALIFIER static vecType<L, T, P> call(vecType<L, T, P> const & a, vecType<L, T, P> const & b)
 		{
-			return detail::functor2<T, P, vecType>::call(std::fmod, a, b);
+			return detail::functor2<L, T, P>::call(std::fmod, a, b);
 		}
 	};
 
-	template <typename T, precision P, template <class, precision> class vecType>
-	struct compute_fmod<T, P, vecType, false>
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	struct compute_fmod<L, T, P, vecType, false>
 	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & a, vecType<T, P> const & b)
+		GLM_FUNC_QUALIFIER static vecType<L, T, P> call(vecType<L, T, P> const & a, vecType<L, T, P> const & b)
 		{
 			return a % b;
 		}
 	};
 }//namespace detail
 
-	template <typename T> 
+	template<typename T> 
 	GLM_FUNC_QUALIFIER bool isdenormal(T const & x)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'isdenormal' only accept floating-point inputs");
@@ -37,54 +37,54 @@ namespace detail
 #		endif
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER typename tvec1<T, P>::bool_type isdenormal
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER typename vec<1, T, P>::bool_type isdenormal
 	(
-		tvec1<T, P> const & x
+		vec<1, T, P> const & x
 	)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'isdenormal' only accept floating-point inputs");
 
-		return typename tvec1<T, P>::bool_type(
+		return typename vec<1, T, P>::bool_type(
 			isdenormal(x.x));
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER typename tvec2<T, P>::bool_type isdenormal
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER typename vec<2, T, P>::bool_type isdenormal
 	(
-		tvec2<T, P> const & x
+		vec<2, T, P> const & x
 	)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'isdenormal' only accept floating-point inputs");
 
-		return typename tvec2<T, P>::bool_type(
+		return typename vec<2, T, P>::bool_type(
 			isdenormal(x.x),
 			isdenormal(x.y));
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER typename tvec3<T, P>::bool_type isdenormal
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER typename vec<3, T, P>::bool_type isdenormal
 	(
-		tvec3<T, P> const & x
+		vec<3, T, P> const & x
 	)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'isdenormal' only accept floating-point inputs");
 
-		return typename tvec3<T, P>::bool_type(
+		return typename vec<3, T, P>::bool_type(
 			isdenormal(x.x),
 			isdenormal(x.y),
 			isdenormal(x.z));
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER typename tvec4<T, P>::bool_type isdenormal
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER typename vec<4, T, P>::bool_type isdenormal
 	(
-		tvec4<T, P> const & x
+		vec<4, T, P> const & x
 	)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'isdenormal' only accept floating-point inputs");
 
-		return typename tvec4<T, P>::bool_type(
+		return typename vec<4, T, P>::bool_type(
 			isdenormal(x.x),
 			isdenormal(x.y),
 			isdenormal(x.z),
@@ -92,21 +92,21 @@ namespace detail
 	}
 
 	// fmod
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER genType fmod(genType x, genType y)
 	{
-		return fmod(tvec1<genType>(x), y).x;
+		return fmod(vec<1, genType>(x), y).x;
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> fmod(vecType<T, P> const & x, T y)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> fmod(vecType<L, T, P> const & x, T y)
 	{
-		return detail::compute_fmod<T, P, vecType, std::numeric_limits<T>::is_iec559>::call(x, vecType<T, P>(y));
+		return detail::compute_fmod<L, T, P, vecType, std::numeric_limits<T>::is_iec559>::call(x, vecType<L, T, P>(y));
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> fmod(vecType<T, P> const & x, vecType<T, P> const & y)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> fmod(vecType<L, T, P> const & x, vecType<L, T, P> const & y)
 	{
-		return detail::compute_fmod<T, P, vecType, std::numeric_limits<T>::is_iec559>::call(x, y);
+		return detail::compute_fmod<L, T, P, vecType, std::numeric_limits<T>::is_iec559>::call(x, y);
 	}
 }//namespace glm
diff --git a/glm/gtx/compatibility.hpp b/glm/gtx/compatibility.hpp
index 00a0539c..e11f7394 100644
--- a/glm/gtx/compatibility.hpp
+++ b/glm/gtx/compatibility.hpp
@@ -38,94 +38,94 @@ namespace glm
 	/// @addtogroup gtx_compatibility
 	/// @{
 
-	template <typename T> GLM_FUNC_QUALIFIER T lerp(T x, T y, T a){return mix(x, y, a);}																					//!< \brief Returns x * (1.0 - a) + y * a, i.e., the linear blend of x and y using the floating-point value a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
-	template <typename T, precision P> GLM_FUNC_QUALIFIER tvec2<T, P> lerp(const tvec2<T, P>& x, const tvec2<T, P>& y, T a){return mix(x, y, a);}							//!< \brief Returns x * (1.0 - a) + y * a, i.e., the linear blend of x and y using the floating-point value a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
+	template<typename T> GLM_FUNC_QUALIFIER T lerp(T x, T y, T a){return mix(x, y, a);}																					//!< \brief Returns x * (1.0 - a) + y * a, i.e., the linear blend of x and y using the floating-point value a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
+	template<typename T, precision P> GLM_FUNC_QUALIFIER vec<2, T, P> lerp(const vec<2, T, P>& x, const vec<2, T, P>& y, T a){return mix(x, y, a);}							//!< \brief Returns x * (1.0 - a) + y * a, i.e., the linear blend of x and y using the floating-point value a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
 
-	template <typename T, precision P> GLM_FUNC_QUALIFIER tvec3<T, P> lerp(const tvec3<T, P>& x, const tvec3<T, P>& y, T a){return mix(x, y, a);}							//!< \brief Returns x * (1.0 - a) + y * a, i.e., the linear blend of x and y using the floating-point value a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
-	template <typename T, precision P> GLM_FUNC_QUALIFIER tvec4<T, P> lerp(const tvec4<T, P>& x, const tvec4<T, P>& y, T a){return mix(x, y, a);}							//!< \brief Returns x * (1.0 - a) + y * a, i.e., the linear blend of x and y using the floating-point value a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
-	template <typename T, precision P> GLM_FUNC_QUALIFIER tvec2<T, P> lerp(const tvec2<T, P>& x, const tvec2<T, P>& y, const tvec2<T, P>& a){return mix(x, y, a);}	//!< \brief Returns the component-wise result of x * (1.0 - a) + y * a, i.e., the linear blend of x and y using vector a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
-	template <typename T, precision P> GLM_FUNC_QUALIFIER tvec3<T, P> lerp(const tvec3<T, P>& x, const tvec3<T, P>& y, const tvec3<T, P>& a){return mix(x, y, a);}	//!< \brief Returns the component-wise result of x * (1.0 - a) + y * a, i.e., the linear blend of x and y using vector a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
-	template <typename T, precision P> GLM_FUNC_QUALIFIER tvec4<T, P> lerp(const tvec4<T, P>& x, const tvec4<T, P>& y, const tvec4<T, P>& a){return mix(x, y, a);}	//!< \brief Returns the component-wise result of x * (1.0 - a) + y * a, i.e., the linear blend of x and y using vector a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
+	template<typename T, precision P> GLM_FUNC_QUALIFIER vec<3, T, P> lerp(const vec<3, T, P>& x, const vec<3, T, P>& y, T a){return mix(x, y, a);}							//!< \brief Returns x * (1.0 - a) + y * a, i.e., the linear blend of x and y using the floating-point value a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
+	template<typename T, precision P> GLM_FUNC_QUALIFIER vec<4, T, P> lerp(const vec<4, T, P>& x, const vec<4, T, P>& y, T a){return mix(x, y, a);}							//!< \brief Returns x * (1.0 - a) + y * a, i.e., the linear blend of x and y using the floating-point value a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
+	template<typename T, precision P> GLM_FUNC_QUALIFIER vec<2, T, P> lerp(const vec<2, T, P>& x, const vec<2, T, P>& y, const vec<2, T, P>& a){return mix(x, y, a);}	//!< \brief Returns the component-wise result of x * (1.0 - a) + y * a, i.e., the linear blend of x and y using vector a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
+	template<typename T, precision P> GLM_FUNC_QUALIFIER vec<3, T, P> lerp(const vec<3, T, P>& x, const vec<3, T, P>& y, const vec<3, T, P>& a){return mix(x, y, a);}	//!< \brief Returns the component-wise result of x * (1.0 - a) + y * a, i.e., the linear blend of x and y using vector a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
+	template<typename T, precision P> GLM_FUNC_QUALIFIER vec<4, T, P> lerp(const vec<4, T, P>& x, const vec<4, T, P>& y, const vec<4, T, P>& a){return mix(x, y, a);}	//!< \brief Returns the component-wise result of x * (1.0 - a) + y * a, i.e., the linear blend of x and y using vector a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
 
-	template <typename T, precision P> GLM_FUNC_QUALIFIER T saturate(T x){return clamp(x, T(0), T(1));}														//!< \brief Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility)
-	template <typename T, precision P> GLM_FUNC_QUALIFIER tvec2<T, P> saturate(const tvec2<T, P>& x){return clamp(x, T(0), T(1));}					//!< \brief Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility)
-	template <typename T, precision P> GLM_FUNC_QUALIFIER tvec3<T, P> saturate(const tvec3<T, P>& x){return clamp(x, T(0), T(1));}					//!< \brief Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility)
-	template <typename T, precision P> GLM_FUNC_QUALIFIER tvec4<T, P> saturate(const tvec4<T, P>& x){return clamp(x, T(0), T(1));}					//!< \brief Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility)
+	template<typename T, precision P> GLM_FUNC_QUALIFIER T saturate(T x){return clamp(x, T(0), T(1));}														//!< \brief Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility)
+	template<typename T, precision P> GLM_FUNC_QUALIFIER vec<2, T, P> saturate(const vec<2, T, P>& x){return clamp(x, T(0), T(1));}					//!< \brief Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility)
+	template<typename T, precision P> GLM_FUNC_QUALIFIER vec<3, T, P> saturate(const vec<3, T, P>& x){return clamp(x, T(0), T(1));}					//!< \brief Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility)
+	template<typename T, precision P> GLM_FUNC_QUALIFIER vec<4, T, P> saturate(const vec<4, T, P>& x){return clamp(x, T(0), T(1));}					//!< \brief Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility)
 
-	template <typename T, precision P> GLM_FUNC_QUALIFIER T atan2(T x, T y){return atan(x, y);}																//!< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility)
-	template <typename T, precision P> GLM_FUNC_QUALIFIER tvec2<T, P> atan2(const tvec2<T, P>& x, const tvec2<T, P>& y){return atan(x, y);}	//!< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility)
-	template <typename T, precision P> GLM_FUNC_QUALIFIER tvec3<T, P> atan2(const tvec3<T, P>& x, const tvec3<T, P>& y){return atan(x, y);}	//!< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility)
-	template <typename T, precision P> GLM_FUNC_QUALIFIER tvec4<T, P> atan2(const tvec4<T, P>& x, const tvec4<T, P>& y){return atan(x, y);}	//!< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility)
+	template<typename T, precision P> GLM_FUNC_QUALIFIER T atan2(T x, T y){return atan(x, y);}																//!< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility)
+	template<typename T, precision P> GLM_FUNC_QUALIFIER vec<2, T, P> atan2(const vec<2, T, P>& x, const vec<2, T, P>& y){return atan(x, y);}	//!< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility)
+	template<typename T, precision P> GLM_FUNC_QUALIFIER vec<3, T, P> atan2(const vec<3, T, P>& x, const vec<3, T, P>& y){return atan(x, y);}	//!< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility)
+	template<typename T, precision P> GLM_FUNC_QUALIFIER vec<4, T, P> atan2(const vec<4, T, P>& x, const vec<4, T, P>& y){return atan(x, y);}	//!< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility)
 
-	template <typename genType> GLM_FUNC_DECL bool isfinite(genType const & x);											//!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
-	template <typename T, precision P> GLM_FUNC_DECL tvec1<bool, P> isfinite(const tvec1<T, P>& x);				//!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
-	template <typename T, precision P> GLM_FUNC_DECL tvec2<bool, P> isfinite(const tvec2<T, P>& x);				//!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
-	template <typename T, precision P> GLM_FUNC_DECL tvec3<bool, P> isfinite(const tvec3<T, P>& x);				//!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
-	template <typename T, precision P> GLM_FUNC_DECL tvec4<bool, P> isfinite(const tvec4<T, P>& x);				//!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
+	template<typename genType> GLM_FUNC_DECL bool isfinite(genType const & x);											//!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
+	template<typename T, precision P> GLM_FUNC_DECL vec<1, bool, P> isfinite(const vec<1, T, P>& x);				//!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
+	template<typename T, precision P> GLM_FUNC_DECL vec<2, bool, P> isfinite(const vec<2, T, P>& x);				//!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
+	template<typename T, precision P> GLM_FUNC_DECL vec<3, bool, P> isfinite(const vec<3, T, P>& x);				//!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
+	template<typename T, precision P> GLM_FUNC_DECL vec<4, bool, P> isfinite(const vec<4, T, P>& x);				//!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
 
 	typedef bool						bool1;			//!< \brief boolean type with 1 component. (From GLM_GTX_compatibility extension)
-	typedef tvec2<bool, highp>			bool2;			//!< \brief boolean type with 2 components. (From GLM_GTX_compatibility extension)
-	typedef tvec3<bool, highp>			bool3;			//!< \brief boolean type with 3 components. (From GLM_GTX_compatibility extension)
-	typedef tvec4<bool, highp>			bool4;			//!< \brief boolean type with 4 components. (From GLM_GTX_compatibility extension)
+	typedef vec<2, bool, highp>			bool2;			//!< \brief boolean type with 2 components. (From GLM_GTX_compatibility extension)
+	typedef vec<3, bool, highp>			bool3;			//!< \brief boolean type with 3 components. (From GLM_GTX_compatibility extension)
+	typedef vec<4, bool, highp>			bool4;			//!< \brief boolean type with 4 components. (From GLM_GTX_compatibility extension)
 
 	typedef bool						bool1x1;		//!< \brief boolean matrix with 1 x 1 component. (From GLM_GTX_compatibility extension)
-	typedef tmat2x2<bool, highp>		bool2x2;		//!< \brief boolean matrix with 2 x 2 components. (From GLM_GTX_compatibility extension)
-	typedef tmat2x3<bool, highp>		bool2x3;		//!< \brief boolean matrix with 2 x 3 components. (From GLM_GTX_compatibility extension)
-	typedef tmat2x4<bool, highp>		bool2x4;		//!< \brief boolean matrix with 2 x 4 components. (From GLM_GTX_compatibility extension)
-	typedef tmat3x2<bool, highp>		bool3x2;		//!< \brief boolean matrix with 3 x 2 components. (From GLM_GTX_compatibility extension)
-	typedef tmat3x3<bool, highp>		bool3x3;		//!< \brief boolean matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
-	typedef tmat3x4<bool, highp>		bool3x4;		//!< \brief boolean matrix with 3 x 4 components. (From GLM_GTX_compatibility extension)
-	typedef tmat4x2<bool, highp>		bool4x2;		//!< \brief boolean matrix with 4 x 2 components. (From GLM_GTX_compatibility extension)
-	typedef tmat4x3<bool, highp>		bool4x3;		//!< \brief boolean matrix with 4 x 3 components. (From GLM_GTX_compatibility extension)
-	typedef tmat4x4<bool, highp>		bool4x4;		//!< \brief boolean matrix with 4 x 4 components. (From GLM_GTX_compatibility extension)
+	typedef mat<2, 2, bool, highp>		bool2x2;		//!< \brief boolean matrix with 2 x 2 components. (From GLM_GTX_compatibility extension)
+	typedef mat<2, 3, bool, highp>		bool2x3;		//!< \brief boolean matrix with 2 x 3 components. (From GLM_GTX_compatibility extension)
+	typedef mat<2, 4, bool, highp>		bool2x4;		//!< \brief boolean matrix with 2 x 4 components. (From GLM_GTX_compatibility extension)
+	typedef mat<3, 2, bool, highp>		bool3x2;		//!< \brief boolean matrix with 3 x 2 components. (From GLM_GTX_compatibility extension)
+	typedef mat<3, 3, bool, highp>		bool3x3;		//!< \brief boolean matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
+	typedef mat<3, 4, bool, highp>		bool3x4;		//!< \brief boolean matrix with 3 x 4 components. (From GLM_GTX_compatibility extension)
+	typedef mat<4, 2, bool, highp>		bool4x2;		//!< \brief boolean matrix with 4 x 2 components. (From GLM_GTX_compatibility extension)
+	typedef mat<4, 3, bool, highp>		bool4x3;		//!< \brief boolean matrix with 4 x 3 components. (From GLM_GTX_compatibility extension)
+	typedef mat<4, 4, bool, highp>		bool4x4;		//!< \brief boolean matrix with 4 x 4 components. (From GLM_GTX_compatibility extension)
 
 	typedef int							int1;			//!< \brief integer vector with 1 component. (From GLM_GTX_compatibility extension)
-	typedef tvec2<int, highp>			int2;			//!< \brief integer vector with 2 components. (From GLM_GTX_compatibility extension)
-	typedef tvec3<int, highp>			int3;			//!< \brief integer vector with 3 components. (From GLM_GTX_compatibility extension)
-	typedef tvec4<int, highp>			int4;			//!< \brief integer vector with 4 components. (From GLM_GTX_compatibility extension)
+	typedef vec<2, int, highp>			int2;			//!< \brief integer vector with 2 components. (From GLM_GTX_compatibility extension)
+	typedef vec<3, int, highp>			int3;			//!< \brief integer vector with 3 components. (From GLM_GTX_compatibility extension)
+	typedef vec<4, int, highp>			int4;			//!< \brief integer vector with 4 components. (From GLM_GTX_compatibility extension)
 
 	typedef int							int1x1;			//!< \brief integer matrix with 1 component. (From GLM_GTX_compatibility extension)
-	typedef tmat2x2<int, highp>		int2x2;			//!< \brief integer matrix with 2 x 2 components. (From GLM_GTX_compatibility extension)
-	typedef tmat2x3<int, highp>		int2x3;			//!< \brief integer matrix with 2 x 3 components. (From GLM_GTX_compatibility extension)
-	typedef tmat2x4<int, highp>		int2x4;			//!< \brief integer matrix with 2 x 4 components. (From GLM_GTX_compatibility extension)
-	typedef tmat3x2<int, highp>		int3x2;			//!< \brief integer matrix with 3 x 2 components. (From GLM_GTX_compatibility extension)
-	typedef tmat3x3<int, highp>		int3x3;			//!< \brief integer matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
-	typedef tmat3x4<int, highp>		int3x4;			//!< \brief integer matrix with 3 x 4 components. (From GLM_GTX_compatibility extension)
-	typedef tmat4x2<int, highp>		int4x2;			//!< \brief integer matrix with 4 x 2 components. (From GLM_GTX_compatibility extension)
-	typedef tmat4x3<int, highp>		int4x3;			//!< \brief integer matrix with 4 x 3 components. (From GLM_GTX_compatibility extension)
-	typedef tmat4x4<int, highp>		int4x4;			//!< \brief integer matrix with 4 x 4 components. (From GLM_GTX_compatibility extension)
+	typedef mat<2, 2, int, highp>		int2x2;			//!< \brief integer matrix with 2 x 2 components. (From GLM_GTX_compatibility extension)
+	typedef mat<2, 3, int, highp>		int2x3;			//!< \brief integer matrix with 2 x 3 components. (From GLM_GTX_compatibility extension)
+	typedef mat<2, 4, int, highp>		int2x4;			//!< \brief integer matrix with 2 x 4 components. (From GLM_GTX_compatibility extension)
+	typedef mat<3, 2, int, highp>		int3x2;			//!< \brief integer matrix with 3 x 2 components. (From GLM_GTX_compatibility extension)
+	typedef mat<3, 3, int, highp>		int3x3;			//!< \brief integer matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
+	typedef mat<3, 4, int, highp>		int3x4;			//!< \brief integer matrix with 3 x 4 components. (From GLM_GTX_compatibility extension)
+	typedef mat<4, 2, int, highp>		int4x2;			//!< \brief integer matrix with 4 x 2 components. (From GLM_GTX_compatibility extension)
+	typedef mat<4, 3, int, highp>		int4x3;			//!< \brief integer matrix with 4 x 3 components. (From GLM_GTX_compatibility extension)
+	typedef mat<4, 4, int, highp>		int4x4;			//!< \brief integer matrix with 4 x 4 components. (From GLM_GTX_compatibility extension)
 
 	typedef float						float1;			//!< \brief single-precision floating-point vector with 1 component. (From GLM_GTX_compatibility extension)
-	typedef tvec2<float, highp>		float2;			//!< \brief single-precision floating-point vector with 2 components. (From GLM_GTX_compatibility extension)
-	typedef tvec3<float, highp>		float3;			//!< \brief single-precision floating-point vector with 3 components. (From GLM_GTX_compatibility extension)
-	typedef tvec4<float, highp>		float4;			//!< \brief single-precision floating-point vector with 4 components. (From GLM_GTX_compatibility extension)
+	typedef vec<2, float, highp>		float2;			//!< \brief single-precision floating-point vector with 2 components. (From GLM_GTX_compatibility extension)
+	typedef vec<3, float, highp>		float3;			//!< \brief single-precision floating-point vector with 3 components. (From GLM_GTX_compatibility extension)
+	typedef vec<4, float, highp>		float4;			//!< \brief single-precision floating-point vector with 4 components. (From GLM_GTX_compatibility extension)
 
 	typedef float						float1x1;		//!< \brief single-precision floating-point matrix with 1 component. (From GLM_GTX_compatibility extension)
-	typedef tmat2x2<float, highp>		float2x2;		//!< \brief single-precision floating-point matrix with 2 x 2 components. (From GLM_GTX_compatibility extension)
-	typedef tmat2x3<float, highp>		float2x3;		//!< \brief single-precision floating-point matrix with 2 x 3 components. (From GLM_GTX_compatibility extension)
-	typedef tmat2x4<float, highp>		float2x4;		//!< \brief single-precision floating-point matrix with 2 x 4 components. (From GLM_GTX_compatibility extension)
-	typedef tmat3x2<float, highp>		float3x2;		//!< \brief single-precision floating-point matrix with 3 x 2 components. (From GLM_GTX_compatibility extension)
-	typedef tmat3x3<float, highp>		float3x3;		//!< \brief single-precision floating-point matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
-	typedef tmat3x4<float, highp>		float3x4;		//!< \brief single-precision floating-point matrix with 3 x 4 components. (From GLM_GTX_compatibility extension)
-	typedef tmat4x2<float, highp>		float4x2;		//!< \brief single-precision floating-point matrix with 4 x 2 components. (From GLM_GTX_compatibility extension)
-	typedef tmat4x3<float, highp>		float4x3;		//!< \brief single-precision floating-point matrix with 4 x 3 components. (From GLM_GTX_compatibility extension)
-	typedef tmat4x4<float, highp>		float4x4;		//!< \brief single-precision floating-point matrix with 4 x 4 components. (From GLM_GTX_compatibility extension)
+	typedef mat<2, 2, float, highp>		float2x2;		//!< \brief single-precision floating-point matrix with 2 x 2 components. (From GLM_GTX_compatibility extension)
+	typedef mat<2, 3, float, highp>		float2x3;		//!< \brief single-precision floating-point matrix with 2 x 3 components. (From GLM_GTX_compatibility extension)
+	typedef mat<2, 4, float, highp>		float2x4;		//!< \brief single-precision floating-point matrix with 2 x 4 components. (From GLM_GTX_compatibility extension)
+	typedef mat<3, 2, float, highp>		float3x2;		//!< \brief single-precision floating-point matrix with 3 x 2 components. (From GLM_GTX_compatibility extension)
+	typedef mat<3, 3, float, highp>		float3x3;		//!< \brief single-precision floating-point matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
+	typedef mat<3, 4, float, highp>		float3x4;		//!< \brief single-precision floating-point matrix with 3 x 4 components. (From GLM_GTX_compatibility extension)
+	typedef mat<4, 2, float, highp>		float4x2;		//!< \brief single-precision floating-point matrix with 4 x 2 components. (From GLM_GTX_compatibility extension)
+	typedef mat<4, 3, float, highp>		float4x3;		//!< \brief single-precision floating-point matrix with 4 x 3 components. (From GLM_GTX_compatibility extension)
+	typedef mat<4, 4, float, highp>		float4x4;		//!< \brief single-precision floating-point matrix with 4 x 4 components. (From GLM_GTX_compatibility extension)
 
 	typedef double						double1;		//!< \brief double-precision floating-point vector with 1 component. (From GLM_GTX_compatibility extension)
-	typedef tvec2<double, highp>		double2;		//!< \brief double-precision floating-point vector with 2 components. (From GLM_GTX_compatibility extension)
-	typedef tvec3<double, highp>		double3;		//!< \brief double-precision floating-point vector with 3 components. (From GLM_GTX_compatibility extension)
-	typedef tvec4<double, highp>		double4;		//!< \brief double-precision floating-point vector with 4 components. (From GLM_GTX_compatibility extension)
+	typedef vec<2, double, highp>		double2;		//!< \brief double-precision floating-point vector with 2 components. (From GLM_GTX_compatibility extension)
+	typedef vec<3, double, highp>		double3;		//!< \brief double-precision floating-point vector with 3 components. (From GLM_GTX_compatibility extension)
+	typedef vec<4, double, highp>		double4;		//!< \brief double-precision floating-point vector with 4 components. (From GLM_GTX_compatibility extension)
 
 	typedef double						double1x1;		//!< \brief double-precision floating-point matrix with 1 component. (From GLM_GTX_compatibility extension)
-	typedef tmat2x2<double, highp>		double2x2;		//!< \brief double-precision floating-point matrix with 2 x 2 components. (From GLM_GTX_compatibility extension)
-	typedef tmat2x3<double, highp>		double2x3;		//!< \brief double-precision floating-point matrix with 2 x 3 components. (From GLM_GTX_compatibility extension)
-	typedef tmat2x4<double, highp>		double2x4;		//!< \brief double-precision floating-point matrix with 2 x 4 components. (From GLM_GTX_compatibility extension)
-	typedef tmat3x2<double, highp>		double3x2;		//!< \brief double-precision floating-point matrix with 3 x 2 components. (From GLM_GTX_compatibility extension)
-	typedef tmat3x3<double, highp>		double3x3;		//!< \brief double-precision floating-point matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
-	typedef tmat3x4<double, highp>		double3x4;		//!< \brief double-precision floating-point matrix with 3 x 4 components. (From GLM_GTX_compatibility extension)
-	typedef tmat4x2<double, highp>		double4x2;		//!< \brief double-precision floating-point matrix with 4 x 2 components. (From GLM_GTX_compatibility extension)
-	typedef tmat4x3<double, highp>		double4x3;		//!< \brief double-precision floating-point matrix with 4 x 3 components. (From GLM_GTX_compatibility extension)
-	typedef tmat4x4<double, highp>		double4x4;		//!< \brief double-precision floating-point matrix with 4 x 4 components. (From GLM_GTX_compatibility extension)
+	typedef mat<2, 2, double, highp>		double2x2;		//!< \brief double-precision floating-point matrix with 2 x 2 components. (From GLM_GTX_compatibility extension)
+	typedef mat<2, 3, double, highp>		double2x3;		//!< \brief double-precision floating-point matrix with 2 x 3 components. (From GLM_GTX_compatibility extension)
+	typedef mat<2, 4, double, highp>		double2x4;		//!< \brief double-precision floating-point matrix with 2 x 4 components. (From GLM_GTX_compatibility extension)
+	typedef mat<3, 2, double, highp>		double3x2;		//!< \brief double-precision floating-point matrix with 3 x 2 components. (From GLM_GTX_compatibility extension)
+	typedef mat<3, 3, double, highp>		double3x3;		//!< \brief double-precision floating-point matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
+	typedef mat<3, 4, double, highp>		double3x4;		//!< \brief double-precision floating-point matrix with 3 x 4 components. (From GLM_GTX_compatibility extension)
+	typedef mat<4, 2, double, highp>		double4x2;		//!< \brief double-precision floating-point matrix with 4 x 2 components. (From GLM_GTX_compatibility extension)
+	typedef mat<4, 3, double, highp>		double4x3;		//!< \brief double-precision floating-point matrix with 4 x 3 components. (From GLM_GTX_compatibility extension)
+	typedef mat<4, 4, double, highp>		double4x4;		//!< \brief double-precision floating-point matrix with 4 x 4 components. (From GLM_GTX_compatibility extension)
 
 	/// @}
 }//namespace glm
diff --git a/glm/gtx/compatibility.inl b/glm/gtx/compatibility.inl
index 368527ac..cf1c07a1 100644
--- a/glm/gtx/compatibility.inl
+++ b/glm/gtx/compatibility.inl
@@ -6,7 +6,7 @@
 namespace glm
 {
 	// isfinite
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER bool isfinite(
 		genType const & x)
 	{
@@ -24,38 +24,38 @@ namespace glm
 #		endif
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec1<bool, P> isfinite(
-		tvec1<T, P> const & x)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<1, bool, P> isfinite(
+		vec<1, T, P> const & x)
 	{
-		return tvec1<bool, P>(
+		return vec<1, bool, P>(
 			isfinite(x.x));
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<bool, P> isfinite(
-		tvec2<T, P> const & x)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<2, bool, P> isfinite(
+		vec<2, T, P> const & x)
 	{
-		return tvec2<bool, P>(
+		return vec<2, bool, P>(
 			isfinite(x.x),
 			isfinite(x.y));
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<bool, P> isfinite(
-		tvec3<T, P> const & x)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, bool, P> isfinite(
+		vec<3, T, P> const & x)
 	{
-		return tvec3<bool, P>(
+		return vec<3, bool, P>(
 			isfinite(x.x),
 			isfinite(x.y),
 			isfinite(x.z));
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<bool, P> isfinite(
-		tvec4<T, P> const & x)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, bool, P> isfinite(
+		vec<4, T, P> const & x)
 	{
-		return tvec4<bool, P>(
+		return vec<4, bool, P>(
 			isfinite(x.x),
 			isfinite(x.y),
 			isfinite(x.z),
diff --git a/glm/gtx/component_wise.hpp b/glm/gtx/component_wise.hpp
index 6dcdffe2..3b35ad19 100644
--- a/glm/gtx/component_wise.hpp
+++ b/glm/gtx/component_wise.hpp
@@ -34,33 +34,33 @@ namespace glm
 	/// Convert an integer vector to a normalized float vector.
 	/// If the parameter value type is already a floating precision type, the value is passed through.
 	/// @see gtx_component_wise
-	template <typename floatType, typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<floatType, P> compNormalize(vecType<T, P> const & v);
+	template<typename floatType, length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, floatType, P> compNormalize(vecType<L, T, P> const & v);
 
 	/// Convert a normalized float vector to an integer vector.
 	/// If the parameter value type is already a floating precision type, the value is passed through.
 	/// @see gtx_component_wise
-	template <typename T, typename floatType, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> compScale(vecType<floatType, P> const & v);
+	template<length_t L, typename T, typename floatType, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, T, P> compScale(vecType<L, floatType, P> const & v);
 
 	/// Add all vector components together. 
 	/// @see gtx_component_wise
-	template <typename genType> 
+	template<typename genType> 
 	GLM_FUNC_DECL typename genType::value_type compAdd(genType const & v);
 
 	/// Multiply all vector components together. 
 	/// @see gtx_component_wise
-	template <typename genType> 
+	template<typename genType> 
 	GLM_FUNC_DECL typename genType::value_type compMul(genType const & v);
 
 	/// Find the minimum value between single vector components.
 	/// @see gtx_component_wise
-	template <typename genType> 
+	template<typename genType> 
 	GLM_FUNC_DECL typename genType::value_type compMin(genType const & v);
 
 	/// Find the maximum value between single vector components.
 	/// @see gtx_component_wise
-	template <typename genType> 
+	template<typename genType> 
 	GLM_FUNC_DECL typename genType::value_type compMax(genType const & v);
 
 	/// @}
diff --git a/glm/gtx/component_wise.inl b/glm/gtx/component_wise.inl
index add3969e..3961f3cd 100644
--- a/glm/gtx/component_wise.inl
+++ b/glm/gtx/component_wise.inl
@@ -6,92 +6,92 @@
 namespace glm{
 namespace detail
 {
-	template <typename T, typename floatType, precision P, template <typename, precision> class vecType, bool isInteger, bool signedType>
+	template<length_t L, typename T, typename floatType, precision P, template<length_t, typename, precision> class vecType, bool isInteger, bool signedType>
 	struct compute_compNormalize
 	{};
 
-	template <typename T, typename floatType, precision P, template <typename, precision> class vecType>
-	struct compute_compNormalize<T, floatType, P, vecType, true, true>
+	template<length_t L, typename T, typename floatType, precision P, template<length_t, typename, precision> class vecType>
+	struct compute_compNormalize<L, T, floatType, P, vecType, true, true>
 	{
-		GLM_FUNC_QUALIFIER static vecType<floatType, P> call(vecType<T, P> const & v)
+		GLM_FUNC_QUALIFIER static vecType<L, floatType, P> call(vecType<L, T, P> const & v)
 		{
 			floatType const Min = static_cast<floatType>(std::numeric_limits<T>::min());
 			floatType const Max = static_cast<floatType>(std::numeric_limits<T>::max());
-			return (vecType<floatType, P>(v) - Min) / (Max - Min) * static_cast<floatType>(2) - static_cast<floatType>(1);
+			return (vecType<L, floatType, P>(v) - Min) / (Max - Min) * static_cast<floatType>(2) - static_cast<floatType>(1);
 		}
 	};
 
-	template <typename T, typename floatType, precision P, template <typename, precision> class vecType>
-	struct compute_compNormalize<T, floatType, P, vecType, true, false>
+	template<length_t L, typename T, typename floatType, precision P, template<length_t, typename, precision> class vecType>
+	struct compute_compNormalize<L, T, floatType, P, vecType, true, false>
 	{
-		GLM_FUNC_QUALIFIER static vecType<floatType, P> call(vecType<T, P> const & v)
+		GLM_FUNC_QUALIFIER static vecType<L, floatType, P> call(vecType<L, T, P> const & v)
 		{
-			return vecType<floatType, P>(v) / static_cast<floatType>(std::numeric_limits<T>::max());
+			return vecType<L, floatType, P>(v) / static_cast<floatType>(std::numeric_limits<T>::max());
 		}
 	};
 
-	template <typename T, typename floatType, precision P, template <typename, precision> class vecType>
-	struct compute_compNormalize<T, floatType, P, vecType, false, true>
+	template<length_t L, typename T, typename floatType, precision P, template<length_t, typename, precision> class vecType>
+	struct compute_compNormalize<L, T, floatType, P, vecType, false, true>
 	{
-		GLM_FUNC_QUALIFIER static vecType<floatType, P> call(vecType<T, P> const & v)
+		GLM_FUNC_QUALIFIER static vecType<L, floatType, P> call(vecType<L, T, P> const & v)
 		{
 			return v;
 		}
 	};
 
-	template <typename T, typename floatType, precision P, template <typename, precision> class vecType, bool isInteger, bool signedType>
+	template<length_t L, typename T, typename floatType, precision P, template<length_t, typename, precision> class vecType, bool isInteger, bool signedType>
 	struct compute_compScale
 	{};
 
-	template <typename T, typename floatType, precision P, template <typename, precision> class vecType>
-	struct compute_compScale<T, floatType, P, vecType, true, true>
+	template<length_t L, typename T, typename floatType, precision P, template<length_t, typename, precision> class vecType>
+	struct compute_compScale<L, T, floatType, P, vecType, true, true>
 	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<floatType, P> const & v)
+		GLM_FUNC_QUALIFIER static vecType<L, T, P> call(vecType<L, floatType, P> const & v)
 		{
 			floatType const Max = static_cast<floatType>(std::numeric_limits<T>::max()) + static_cast<floatType>(0.5);
-			vecType<floatType, P> const Scaled(v * Max);
-			vecType<T, P> const Result(Scaled - static_cast<floatType>(0.5));
+			vecType<L, floatType, P> const Scaled(v * Max);
+			vecType<L, T, P> const Result(Scaled - static_cast<floatType>(0.5));
 			return Result;
 		}
 	};
 
-	template <typename T, typename floatType, precision P, template <typename, precision> class vecType>
-	struct compute_compScale<T, floatType, P, vecType, true, false>
+	template<length_t L, typename T, typename floatType, precision P, template<length_t, typename, precision> class vecType>
+	struct compute_compScale<L, T, floatType, P, vecType, true, false>
 	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<floatType, P> const & v)
+		GLM_FUNC_QUALIFIER static vecType<L, T, P> call(vecType<L, floatType, P> const & v)
 		{
-			return vecType<T, P>(vecType<floatType, P>(v) * static_cast<floatType>(std::numeric_limits<T>::max()));
+			return vecType<L, T, P>(vecType<L, floatType, P>(v) * static_cast<floatType>(std::numeric_limits<T>::max()));
 		}
 	};
 
-	template <typename T, typename floatType, precision P, template <typename, precision> class vecType>
-	struct compute_compScale<T, floatType, P, vecType, false, true>
+	template<length_t L, typename T, typename floatType, precision P, template<length_t, typename, precision> class vecType>
+	struct compute_compScale<L, T, floatType, P, vecType, false, true>
 	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<floatType, P> const & v)
+		GLM_FUNC_QUALIFIER static vecType<L, T, P> call(vecType<L, floatType, P> const & v)
 		{
 			return v;
 		}
 	};
 }//namespace detail
 
-	template <typename floatType, typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<floatType, P> compNormalize(vecType<T, P> const & v)
+	template<typename floatType, length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, floatType, P> compNormalize(vecType<L, T, P> const & v)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<floatType>::is_iec559, "'compNormalize' accepts only floating-point types for 'floatType' template parameter");
 
-		return detail::compute_compNormalize<T, floatType, P, vecType, std::numeric_limits<T>::is_integer, std::numeric_limits<T>::is_signed>::call(v);
+		return detail::compute_compNormalize<L, T, floatType, P, vecType, std::numeric_limits<T>::is_integer, std::numeric_limits<T>::is_signed>::call(v);
 	}
 
-	template <typename T, typename floatType, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> compScale(vecType<floatType, P> const & v)
+	template<typename T, length_t L, typename floatType, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> compScale(vecType<L, floatType, P> const & v)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<floatType>::is_iec559, "'compScale' accepts only floating-point types for 'floatType' template parameter");
 
-		return detail::compute_compScale<T, floatType, P, vecType, std::numeric_limits<T>::is_integer, std::numeric_limits<T>::is_signed>::call(v);
+		return detail::compute_compScale<L, T, floatType, P, vecType, std::numeric_limits<T>::is_integer, std::numeric_limits<T>::is_signed>::call(v);
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER T compAdd(vecType<T, P> const & v)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER T compAdd(vecType<L, T, P> const & v)
 	{
 		T Result(0);
 		for(length_t i = 0, n = v.length(); i < n; ++i)
@@ -99,8 +99,8 @@ namespace detail
 		return Result;
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER T compMul(vecType<T, P> const & v)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER T compMul(vecType<L, T, P> const & v)
 	{
 		T Result(1);
 		for(length_t i = 0, n = v.length(); i < n; ++i)
@@ -108,8 +108,8 @@ namespace detail
 		return Result;
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER T compMin(vecType<T, P> const & v)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER T compMin(vecType<L, T, P> const & v)
 	{
 		T Result(v[0]);
 		for(length_t i = 1, n = v.length(); i < n; ++i)
@@ -117,8 +117,8 @@ namespace detail
 		return Result;
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER T compMax(vecType<T, P> const & v)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER T compMax(vecType<L, T, P> const & v)
 	{
 		T Result(v[0]);
 		for(length_t i = 1, n = v.length(); i < n; ++i)
diff --git a/glm/gtx/dual_quaternion.hpp b/glm/gtx/dual_quaternion.hpp
index 416af456..1fa23f57 100644
--- a/glm/gtx/dual_quaternion.hpp
+++ b/glm/gtx/dual_quaternion.hpp
@@ -33,7 +33,7 @@ namespace glm
 	/// @addtogroup gtx_dual_quaternion
 	/// @{
 
-	template <typename T, precision P = defaultp>
+	template<typename T, precision P = defaultp>
 	struct tdualquat
 	{
 		// -- Implementation detail --
@@ -58,122 +58,122 @@ namespace glm
 
 		GLM_FUNC_DECL GLM_CONSTEXPR tdualquat() GLM_DEFAULT_CTOR;
 		GLM_FUNC_DECL GLM_CONSTEXPR tdualquat(tdualquat<T, P> const & d) GLM_DEFAULT;
-		template <precision Q>
+		template<precision Q>
 		GLM_FUNC_DECL GLM_CONSTEXPR tdualquat(tdualquat<T, Q> const & d);
 
 		// -- Explicit basic constructors --
 
 		GLM_FUNC_DECL GLM_CONSTEXPR_CTOR explicit tdualquat(ctor);
 		GLM_FUNC_DECL GLM_CONSTEXPR tdualquat(tquat<T, P> const & real);
-		GLM_FUNC_DECL GLM_CONSTEXPR tdualquat(tquat<T, P> const & orientation, tvec3<T, P> const & translation);
+		GLM_FUNC_DECL GLM_CONSTEXPR tdualquat(tquat<T, P> const & orientation, vec<3, T, P> const & translation);
 		GLM_FUNC_DECL GLM_CONSTEXPR tdualquat(tquat<T, P> const & real, tquat<T, P> const & dual);
 
 		// -- Conversion constructors --
 
-		template <typename U, precision Q>
+		template<typename U, precision Q>
 		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tdualquat(tdualquat<U, Q> const & q);
 
-		GLM_FUNC_DECL GLM_EXPLICIT tdualquat(tmat2x4<T, P> const & holder_mat);
-		GLM_FUNC_DECL GLM_EXPLICIT tdualquat(tmat3x4<T, P> const & aug_mat);
+		GLM_FUNC_DECL GLM_EXPLICIT tdualquat(mat<2, 4, T, P> const & holder_mat);
+		GLM_FUNC_DECL GLM_EXPLICIT tdualquat(mat<3, 4, T, P> const & aug_mat);
 
 		// -- Unary arithmetic operators --
 
 		GLM_FUNC_DECL tdualquat<T, P> & operator=(tdualquat<T, P> const & m) GLM_DEFAULT;
 
-		template <typename U>
+		template<typename U>
 		GLM_FUNC_DECL tdualquat<T, P> & operator=(tdualquat<U, P> const & m);
-		template <typename U>
+		template<typename U>
 		GLM_FUNC_DECL tdualquat<T, P> & operator*=(U s);
-		template <typename U>
+		template<typename U>
 		GLM_FUNC_DECL tdualquat<T, P> & operator/=(U s);
 	};
 
 	// -- Unary bit operators --
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_DECL tdualquat<T, P> operator+(tdualquat<T, P> const & q);
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_DECL tdualquat<T, P> operator-(tdualquat<T, P> const & q);
 
 	// -- Binary operators --
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_DECL tdualquat<T, P> operator+(tdualquat<T, P> const & q, tdualquat<T, P> const & p);
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_DECL tdualquat<T, P> operator*(tdualquat<T, P> const & q, tdualquat<T, P> const & p);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> operator*(tdualquat<T, P> const & q, tvec3<T, P> const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<3, T, P> operator*(tdualquat<T, P> const & q, vec<3, T, P> const & v);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> operator*(tvec3<T, P> const & v, tdualquat<T, P> const & q);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<3, T, P> operator*(vec<3, T, P> const & v, tdualquat<T, P> const & q);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec4<T, P> operator*(tdualquat<T, P> const & q, tvec4<T, P> const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<4, T, P> operator*(tdualquat<T, P> const & q, vec<4, T, P> const & v);
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec4<T, P> operator*(tvec4<T, P> const & v, tdualquat<T, P> const & q);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<4, T, P> operator*(vec<4, T, P> const & v, tdualquat<T, P> const & q);
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_DECL tdualquat<T, P> operator*(tdualquat<T, P> const & q, T const & s);
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_DECL tdualquat<T, P> operator*(T const & s, tdualquat<T, P> const & q);
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_DECL tdualquat<T, P> operator/(tdualquat<T, P> const & q, T const & s);
 
 	// -- Boolean operators --
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_DECL bool operator==(tdualquat<T, P> const & q1, tdualquat<T, P> const & q2);
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_DECL bool operator!=(tdualquat<T, P> const & q1, tdualquat<T, P> const & q2);
 
 	/// Returns the normalized quaternion.
 	///
 	/// @see gtx_dual_quaternion
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_DECL tdualquat<T, P> normalize(tdualquat<T, P> const & q);
 
 	/// Returns the linear interpolation of two dual quaternion.
 	///
 	/// @see gtc_dual_quaternion
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_DECL tdualquat<T, P> lerp(tdualquat<T, P> const & x, tdualquat<T, P> const & y, T const & a);
 
 	/// Returns the q inverse.
 	///
 	/// @see gtx_dual_quaternion
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_DECL tdualquat<T, P> inverse(tdualquat<T, P> const & q);
 
 	/// Converts a quaternion to a 2 * 4 matrix.
 	///
 	/// @see gtx_dual_quaternion
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x4<T, P> mat2x4_cast(tdualquat<T, P> const & x);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<2, 4, T, P> mat2x4_cast(tdualquat<T, P> const & x);
 
 	/// Converts a quaternion to a 3 * 4 matrix.
 	///
 	/// @see gtx_dual_quaternion
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat3x4<T, P> mat3x4_cast(tdualquat<T, P> const & x);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<3, 4, T, P> mat3x4_cast(tdualquat<T, P> const & x);
 
 	/// Converts a 2 * 4 matrix (matrix which holds real and dual parts) to a quaternion.
 	///
 	/// @see gtx_dual_quaternion
-	template <typename T, precision P>
-	GLM_FUNC_DECL tdualquat<T, P> dualquat_cast(tmat2x4<T, P> const & x);
+	template<typename T, precision P>
+	GLM_FUNC_DECL tdualquat<T, P> dualquat_cast(mat<2, 4, T, P> const & x);
 
 	/// Converts a 3 * 4 matrix (augmented matrix rotation + translation) to a quaternion.
 	///
 	/// @see gtx_dual_quaternion
-	template <typename T, precision P>
-	GLM_FUNC_DECL tdualquat<T, P> dualquat_cast(tmat3x4<T, P> const & x);
+	template<typename T, precision P>
+	GLM_FUNC_DECL tdualquat<T, P> dualquat_cast(mat<3, 4, T, P> const & x);
 
 
 	/// Dual-quaternion of low single-precision floating-point numbers.
diff --git a/glm/gtx/dual_quaternion.inl b/glm/gtx/dual_quaternion.inl
index c3f2bc62..df330ffa 100644
--- a/glm/gtx/dual_quaternion.inl
+++ b/glm/gtx/dual_quaternion.inl
@@ -8,14 +8,14 @@ namespace glm
 {
 	// -- Component accesses --
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER typename tdualquat<T, P>::part_type & tdualquat<T, P>::operator[](typename tdualquat<T, P>::length_type i)
 	{
 		assert(i >= 0 && i < this->length());
 		return (&real)[i];
 	}
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER typename tdualquat<T, P>::part_type const & tdualquat<T, P>::operator[](typename tdualquat<T, P>::length_type i) const
 	{
 		assert(i >= 0 && i < this->length());
@@ -25,7 +25,7 @@ namespace glm
 	// -- Implicit basic constructors --
 
 #	if !GLM_HAS_DEFAULTED_FUNCTIONS || !defined(GLM_FORCE_NO_CTOR_INIT)
-		template <typename T, precision P>
+		template<typename T, precision P>
 		GLM_FUNC_QUALIFIER GLM_CONSTEXPR tdualquat<T, P>::tdualquat()
 #			ifndef GLM_FORCE_NO_CTOR_INIT 
 				: real(tquat<T, P>())
@@ -35,15 +35,15 @@ namespace glm
 #	endif
 
 #	if !GLM_HAS_DEFAULTED_FUNCTIONS
-		template <typename T, precision P>
+		template<typename T, precision P>
 		GLM_FUNC_QUALIFIER GLM_CONSTEXPR tdualquat<T, P>::tdualquat(tdualquat<T, P> const & d)
 			: real(d.real)
 			, dual(d.dual)
 		{}
 #	endif//!GLM_HAS_DEFAULTED_FUNCTIONS
 
-	template <typename T, precision P>
-	template <precision Q>
+	template<typename T, precision P>
+	template<precision Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tdualquat<T, P>::tdualquat(tdualquat<T, Q> const & d)
 		: real(d.real)
 		, dual(d.dual)
@@ -51,17 +51,17 @@ namespace glm
 
 	// -- Explicit basic constructors --
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR tdualquat<T, P>::tdualquat(ctor)
 	{}
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tdualquat<T, P>::tdualquat(tquat<T, P> const & r)
 		: real(r), dual(tquat<T, P>(0, 0, 0, 0))
 	{}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tdualquat<T, P>::tdualquat(tquat<T, P> const & q, tvec3<T, P> const& p)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tdualquat<T, P>::tdualquat(tquat<T, P> const & q, vec<3, T, P> const& p)
 		: real(q), dual(
 			T(-0.5) * ( p.x*q.x + p.y*q.y + p.z*q.z),
 			T(+0.5) * ( p.x*q.w + p.y*q.z - p.z*q.y),
@@ -69,28 +69,28 @@ namespace glm
 			T(+0.5) * ( p.x*q.y - p.y*q.x + p.z*q.w))
 	{}
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tdualquat<T, P>::tdualquat(tquat<T, P> const & r, tquat<T, P> const & d)
 		: real(r), dual(d)
 	{}
 
 	// -- Conversion constructors --
 
-	template <typename T, precision P>
-	template <typename U, precision Q>
+	template<typename T, precision P>
+	template<typename U, precision Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tdualquat<T, P>::tdualquat(tdualquat<U, Q> const & q)
 		: real(q.real)
 		, dual(q.dual)
 	{}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tdualquat<T, P>::tdualquat(tmat2x4<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER tdualquat<T, P>::tdualquat(mat<2, 4, T, P> const & m)
 	{
 		*this = dualquat_cast(m);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tdualquat<T, P>::tdualquat(tmat3x4<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER tdualquat<T, P>::tdualquat(mat<3, 4, T, P> const & m)
 	{
 		*this = dualquat_cast(m);
 	}
@@ -98,7 +98,7 @@ namespace glm
 	// -- Unary arithmetic operators --
 
 #	if !GLM_HAS_DEFAULTED_FUNCTIONS
-		template <typename T, precision P>
+		template<typename T, precision P>
 		GLM_FUNC_QUALIFIER tdualquat<T, P> & tdualquat<T, P>::operator=(tdualquat<T, P> const & q)
 		{
 			this->real = q.real;
@@ -107,8 +107,8 @@ namespace glm
 		}
 #	endif//!GLM_HAS_DEFAULTED_FUNCTIONS
 
-	template <typename T, precision P>
-	template <typename U>
+	template<typename T, precision P>
+	template<typename U>
 	GLM_FUNC_QUALIFIER tdualquat<T, P> & tdualquat<T, P>::operator=(tdualquat<U, P> const & q)
 	{
 		this->real = q.real;
@@ -116,8 +116,8 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
+	template<typename T, precision P>
+	template<typename U>
 	GLM_FUNC_QUALIFIER tdualquat<T, P> & tdualquat<T, P>::operator*=(U s)
 	{
 		this->real *= static_cast<T>(s);
@@ -125,8 +125,8 @@ namespace glm
 		return *this;
 	}
 
-	template <typename T, precision P>
-	template <typename U>
+	template<typename T, precision P>
+	template<typename U>
 	GLM_FUNC_QUALIFIER tdualquat<T, P> & tdualquat<T, P>::operator/=(U s)
 	{
 		this->real /= static_cast<T>(s);
@@ -136,13 +136,13 @@ namespace glm
 
 	// -- Unary bit operators --
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER tdualquat<T, P> operator+(tdualquat<T, P> const & q)
 	{
 		return q;
 	}
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER tdualquat<T, P> operator-(tdualquat<T, P> const & q)
 	{
 		return tdualquat<T, P>(-q.real, -q.dual);
@@ -150,57 +150,57 @@ namespace glm
 
 	// -- Binary operators --
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER tdualquat<T, P> operator+(tdualquat<T, P> const & q, tdualquat<T, P> const & p)
 	{
 		return tdualquat<T, P>(q.real + p.real,q.dual + p.dual);
 	}
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER tdualquat<T, P> operator*(tdualquat<T, P> const & p, tdualquat<T, P> const & o)
 	{
 		return tdualquat<T, P>(p.real * o.real,p.real * o.dual + p.dual * o.real);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> operator*(tdualquat<T, P> const & q, tvec3<T, P> const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> operator*(tdualquat<T, P> const & q, vec<3, T, P> const & v)
 	{
-		tvec3<T, P> const real_v3(q.real.x,q.real.y,q.real.z);
-		tvec3<T, P> const dual_v3(q.dual.x,q.dual.y,q.dual.z);
+		vec<3, T, P> const real_v3(q.real.x,q.real.y,q.real.z);
+		vec<3, T, P> const dual_v3(q.dual.x,q.dual.y,q.dual.z);
 		return (cross(real_v3, cross(real_v3,v) + v * q.real.w + dual_v3) + dual_v3 * q.real.w - real_v3 * q.dual.w) * T(2) + v;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> operator*(tvec3<T, P> const & v,	tdualquat<T, P> const & q)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> operator*(vec<3, T, P> const & v,	tdualquat<T, P> const & q)
 	{
 		return glm::inverse(q) * v;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> operator*(tdualquat<T, P> const & q, tvec4<T, P> const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, T, P> operator*(tdualquat<T, P> const & q, vec<4, T, P> const & v)
 	{
-		return tvec4<T, P>(q * tvec3<T, P>(v), v.w);
+		return vec<4, T, P>(q * vec<3, T, P>(v), v.w);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> operator*(tvec4<T, P> const & v,	tdualquat<T, P> const & q)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, T, P> operator*(vec<4, T, P> const & v,	tdualquat<T, P> const & q)
 	{
 		return glm::inverse(q) * v;
 	}
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER tdualquat<T, P> operator*(tdualquat<T, P> const & q, T const & s)
 	{
 		return tdualquat<T, P>(q.real * s, q.dual * s);
 	}
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER tdualquat<T, P> operator*(T const & s, tdualquat<T, P> const & q)
 	{
 		return q * s;
 	}
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER tdualquat<T, P> operator/(tdualquat<T, P> const & q,	T const & s)
 	{
 		return tdualquat<T, P>(q.real / s, q.dual / s);
@@ -208,13 +208,13 @@ namespace glm
 
 	// -- Boolean operators --
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER bool operator==(tdualquat<T, P> const & q1, tdualquat<T, P> const & q2)
 	{
 		return (q1.real == q2.real) && (q1.dual == q2.dual);
 	}
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER bool operator!=(tdualquat<T, P> const & q1, tdualquat<T, P> const & q2)
 	{
 		return (q1.real != q2.dual) || (q1.real != q2.dual);
@@ -222,13 +222,13 @@ namespace glm
 
 	// -- Operations --
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER tdualquat<T, P> normalize(tdualquat<T, P> const & q)
 	{
 		return q / length(q.real);
 	}
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER tdualquat<T, P> lerp(tdualquat<T, P> const & x, tdualquat<T, P> const & y, T const & a)
 	{
 		// Dual Quaternion Linear blend aka DLB:
@@ -240,7 +240,7 @@ namespace glm
 		return tdualquat<T, P>(x * (one - a) + y * k);
 	}
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER tdualquat<T, P> inverse(tdualquat<T, P> const & q)
 	{
 		const glm::tquat<T, P> real = conjugate(q.real);
@@ -248,14 +248,14 @@ namespace glm
 		return tdualquat<T, P>(real, dual + (real * (-2.0f * dot(real,dual))));
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P> mat2x4_cast(tdualquat<T, P> const & x)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, P> mat2x4_cast(tdualquat<T, P> const & x)
 	{
-		return tmat2x4<T, P>( x[0].x, x[0].y, x[0].z, x[0].w, x[1].x, x[1].y, x[1].z, x[1].w );
+		return mat<2, 4, T, P>( x[0].x, x[0].y, x[0].z, x[0].w, x[1].x, x[1].y, x[1].z, x[1].w );
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x4<T, P> mat3x4_cast(tdualquat<T, P> const & x)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, P> mat3x4_cast(tdualquat<T, P> const & x)
 	{
 		tquat<T, P> r = x.real / length2(x.real);
 		
@@ -269,37 +269,37 @@ namespace glm
 		T const wy = r.w * x.real.y;
 		T const wz = r.w * x.real.z;
 		
-		tvec4<T, P> const a(
+		vec<4, T, P> const a(
 			rr.w + rr.x - rr.y - rr.z,
 			xy - wz,
 			xz + wy,
 			-(x.dual.w * r.x - x.dual.x * r.w + x.dual.y * r.z - x.dual.z * r.y));
 		
-		tvec4<T, P> const b(
+		vec<4, T, P> const b(
 			xy + wz,
 			rr.w + rr.y - rr.x - rr.z,
 			yz - wx,
 			-(x.dual.w * r.y - x.dual.x * r.z - x.dual.y * r.w + x.dual.z * r.x));
 		
-		tvec4<T, P> const c(
+		vec<4, T, P> const c(
 			xz - wy,
 			yz + wx,
 			rr.w + rr.z - rr.x - rr.y,
 			-(x.dual.w * r.z + x.dual.x * r.y - x.dual.y * r.x - x.dual.z * r.w));
 		
-		return tmat3x4<T, P>(a, b, c);
+		return mat<3, 4, T, P>(a, b, c);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tdualquat<T, P> dualquat_cast(tmat2x4<T, P> const & x)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER tdualquat<T, P> dualquat_cast(mat<2, 4, T, P> const & x)
 	{
 		return tdualquat<T, P>(
 			tquat<T, P>( x[0].w, x[0].x, x[0].y, x[0].z ),
 			tquat<T, P>( x[1].w, x[1].x, x[1].y, x[1].z ));
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tdualquat<T, P> dualquat_cast(tmat3x4<T, P> const & x)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER tdualquat<T, P> dualquat_cast(mat<3, 4, T, P> const & x)
 	{
 		tquat<T, P> real(uninitialize);
 		
diff --git a/glm/gtx/euler_angles.hpp b/glm/gtx/euler_angles.hpp
index 7aa7561a..6985faa6 100644
--- a/glm/gtx/euler_angles.hpp
+++ b/glm/gtx/euler_angles.hpp
@@ -30,112 +30,112 @@ namespace glm
 
 	/// Creates a 3D 4 * 4 homogeneous rotation matrix from an euler angle X.
 	/// @see gtx_euler_angles
-	template <typename T>
-	GLM_FUNC_DECL tmat4x4<T, defaultp> eulerAngleX(
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleX(
 		T const & angleX);
 
 	/// Creates a 3D 4 * 4 homogeneous rotation matrix from an euler angle Y.
 	/// @see gtx_euler_angles
-	template <typename T>
-	GLM_FUNC_DECL tmat4x4<T, defaultp> eulerAngleY(
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleY(
 		T const & angleY);
 
 	/// Creates a 3D 4 * 4 homogeneous rotation matrix from an euler angle Z.
 	/// @see gtx_euler_angles
-	template <typename T>
-	GLM_FUNC_DECL tmat4x4<T, defaultp> eulerAngleZ(
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleZ(
 		T const & angleZ);
 
 	/// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (X * Y).
 	/// @see gtx_euler_angles
-	template <typename T>
-	GLM_FUNC_DECL tmat4x4<T, defaultp> eulerAngleXY(
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleXY(
 		T const & angleX,
 		T const & angleY);
 
 	/// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X).
 	/// @see gtx_euler_angles
-	template <typename T>
-	GLM_FUNC_DECL tmat4x4<T, defaultp> eulerAngleYX(
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleYX(
 		T const & angleY,
 		T const & angleX);
 
 	/// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (X * Z).
 	/// @see gtx_euler_angles
-	template <typename T>
-	GLM_FUNC_DECL tmat4x4<T, defaultp> eulerAngleXZ(
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleXZ(
 		T const & angleX,
 		T const & angleZ);
 
 	/// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Z * X).
 	/// @see gtx_euler_angles
-	template <typename T>
-	GLM_FUNC_DECL tmat4x4<T, defaultp> eulerAngleZX(
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleZX(
 		T const & angle,
 		T const & angleX);
 
 	/// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * Z).
 	/// @see gtx_euler_angles
-	template <typename T>
-	GLM_FUNC_DECL tmat4x4<T, defaultp> eulerAngleYZ(
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleYZ(
 		T const & angleY,
 		T const & angleZ);
 
 	/// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Z * Y).
 	/// @see gtx_euler_angles
-	template <typename T>
-	GLM_FUNC_DECL tmat4x4<T, defaultp> eulerAngleZY(
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleZY(
 		T const & angleZ,
 		T const & angleY);
 
     /// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (X * Y * Z).
     /// @see gtx_euler_angles
-    template <typename T>
-    GLM_FUNC_DECL tmat4x4<T, defaultp> eulerAngleXYZ(
+    template<typename T>
+    GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleXYZ(
         T const & t1,
         T const & t2,
         T const & t3);
     
 	/// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X * Z).
 	/// @see gtx_euler_angles
-	template <typename T>
-	GLM_FUNC_DECL tmat4x4<T, defaultp> eulerAngleYXZ(
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> eulerAngleYXZ(
 		T const & yaw,
 		T const & pitch,
 		T const & roll);
     
 	/// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X * Z).
 	/// @see gtx_euler_angles
-	template <typename T>
-	GLM_FUNC_DECL tmat4x4<T, defaultp> yawPitchRoll(
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> yawPitchRoll(
 		T const & yaw,
 		T const & pitch,
 		T const & roll);
 
 	/// Creates a 2D 2 * 2 rotation matrix from an euler angle.
 	/// @see gtx_euler_angles
-	template <typename T>
-	GLM_FUNC_DECL tmat2x2<T, defaultp> orientate2(T const & angle);
+	template<typename T>
+	GLM_FUNC_DECL mat<2, 2, T, defaultp> orientate2(T const & angle);
 
 	/// Creates a 2D 4 * 4 homogeneous rotation matrix from an euler angle.
 	/// @see gtx_euler_angles
-	template <typename T>
-	GLM_FUNC_DECL tmat3x3<T, defaultp> orientate3(T const & angle);
+	template<typename T>
+	GLM_FUNC_DECL mat<3, 3, T, defaultp> orientate3(T const & angle);
 
 	/// Creates a 3D 3 * 3 rotation matrix from euler angles (Y * X * Z). 
 	/// @see gtx_euler_angles
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat3x3<T, P> orientate3(tvec3<T, P> const & angles);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<3, 3, T, P> orientate3(vec<3, T, P> const & angles);
 		
 	/// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X * Z).
 	/// @see gtx_euler_angles
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat4x4<T, P> orientate4(tvec3<T, P> const & angles);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<4, 4, T, P> orientate4(vec<3, T, P> const & angles);
 
     /// Extracts the (X * Y * Z) Euler angles from the rotation matrix M
     /// @see gtx_euler_angles
-    template <typename T>
-    GLM_FUNC_DECL void extractEulerAngleXYZ(tmat4x4<T, defaultp> const & M,
+    template<typename T>
+    GLM_FUNC_DECL void extractEulerAngleXYZ(mat<4, 4, T, defaultp> const & M,
                                             T & t1,
                                             T & t2,
                                             T & t3);
diff --git a/glm/gtx/euler_angles.inl b/glm/gtx/euler_angles.inl
index dbe0a48b..bed37416 100644
--- a/glm/gtx/euler_angles.inl
+++ b/glm/gtx/euler_angles.inl
@@ -5,8 +5,8 @@
 
 namespace glm
 {
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> eulerAngleX
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleX
 	(
 		T const & angleX
 	)
@@ -14,15 +14,15 @@ namespace glm
 		T cosX = glm::cos(angleX);
 		T sinX = glm::sin(angleX);
 	
-		return tmat4x4<T, defaultp>(
+		return mat<4, 4, T, defaultp>(
 			T(1), T(0), T(0), T(0),
 			T(0), cosX, sinX, T(0),
 			T(0),-sinX, cosX, T(0),
 			T(0), T(0), T(0), T(1));
 	}
 
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> eulerAngleY
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleY
 	(
 		T const & angleY
 	)
@@ -30,15 +30,15 @@ namespace glm
 		T cosY = glm::cos(angleY);
 		T sinY = glm::sin(angleY);
 
-		return tmat4x4<T, defaultp>(
+		return mat<4, 4, T, defaultp>(
 			cosY,	T(0),	-sinY,	T(0),
 			T(0),	T(1),	T(0),	T(0),
 			sinY,	T(0),	cosY,	T(0),
 			T(0),	T(0),	T(0),	T(1));
 	}
 
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> eulerAngleZ
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleZ
 	(
 		T const & angleZ
 	)
@@ -46,15 +46,15 @@ namespace glm
 		T cosZ = glm::cos(angleZ);
 		T sinZ = glm::sin(angleZ);
 
-		return tmat4x4<T, defaultp>(
+		return mat<4, 4, T, defaultp>(
 			cosZ,	sinZ,	T(0), T(0),
 			-sinZ,	cosZ,	T(0), T(0),
 			T(0),	T(0),	T(1), T(0),
 			T(0),	T(0),	T(0), T(1));
 	}
 
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> eulerAngleXY
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleXY
 	(
 		T const & angleX,
 		T const & angleY
@@ -65,15 +65,15 @@ namespace glm
 		T cosY = glm::cos(angleY);
 		T sinY = glm::sin(angleY);
 
-		return tmat4x4<T, defaultp>(
+		return mat<4, 4, T, defaultp>(
 			cosY,   -sinX * -sinY,  cosX * -sinY,   T(0),
 			T(0),   cosX,           sinX,           T(0),
 			sinY,   -sinX * cosY,   cosX * cosY,    T(0),
 			T(0),   T(0),           T(0),           T(1));
 	}
 
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> eulerAngleYX
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleYX
 	(
 		T const & angleY,
 		T const & angleX
@@ -84,15 +84,15 @@ namespace glm
 		T cosY = glm::cos(angleY);
 		T sinY = glm::sin(angleY);
 
-		return tmat4x4<T, defaultp>(
+		return mat<4, 4, T, defaultp>(
 			cosY,          0,      -sinY,    T(0),
 			sinY * sinX,  cosX, cosY * sinX, T(0),
 			sinY * cosX, -sinX, cosY * cosX, T(0),
 			T(0),         T(0),     T(0),    T(1));
 	}
 
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> eulerAngleXZ
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleXZ
 	(
 		T const & angleX,
 		T const & angleZ
@@ -101,8 +101,8 @@ namespace glm
 		return eulerAngleX(angleX) * eulerAngleZ(angleZ);
 	}
 
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> eulerAngleZX
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleZX
 	(
 		T const & angleZ,
 		T const & angleX
@@ -111,8 +111,8 @@ namespace glm
 		return eulerAngleZ(angleZ) * eulerAngleX(angleX);
 	}
 
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> eulerAngleYZ
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleYZ
 	(
 		T const & angleY,
 		T const & angleZ
@@ -121,8 +121,8 @@ namespace glm
 		return eulerAngleY(angleY) * eulerAngleZ(angleZ);
 	}
 
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> eulerAngleZY
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleZY
 	(
 		T const & angleZ,
 		T const & angleY
@@ -131,8 +131,8 @@ namespace glm
 		return eulerAngleZ(angleZ) * eulerAngleY(angleY);
 	}
     
-    template <typename T>
-    GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> eulerAngleXYZ
+    template<typename T>
+    GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleXYZ
     (
      T const & t1,
      T const & t2,
@@ -146,7 +146,7 @@ namespace glm
         T s2 = glm::sin(-t2);
         T s3 = glm::sin(-t3);
         
-        tmat4x4<T, defaultp> Result;
+        mat<4, 4, T, defaultp> Result;
         Result[0][0] = c2 * c3;
         Result[0][1] =-c1 * s3 + s1 * s2 * c3;
         Result[0][2] = s1 * s3 + c1 * s2 * c3;
@@ -166,8 +166,8 @@ namespace glm
         return Result;
     }
     
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> eulerAngleYXZ
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> eulerAngleYXZ
 	(
 		T const & yaw,
 		T const & pitch,
@@ -181,7 +181,7 @@ namespace glm
 		T tmp_cb = glm::cos(roll);
 		T tmp_sb = glm::sin(roll);
 
-		tmat4x4<T, defaultp> Result;
+		mat<4, 4, T, defaultp> Result;
 		Result[0][0] = tmp_ch * tmp_cb + tmp_sh * tmp_sp * tmp_sb;
 		Result[0][1] = tmp_sb * tmp_cp;
 		Result[0][2] = -tmp_sh * tmp_cb + tmp_ch * tmp_sp * tmp_sb;
@@ -201,8 +201,8 @@ namespace glm
 		return Result;
 	}
 
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> yawPitchRoll
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> yawPitchRoll
 	(
 		T const & yaw,
 		T const & pitch,
@@ -216,7 +216,7 @@ namespace glm
 		T tmp_cb = glm::cos(roll);
 		T tmp_sb = glm::sin(roll);
 
-		tmat4x4<T, defaultp> Result;
+		mat<4, 4, T, defaultp> Result;
 		Result[0][0] = tmp_ch * tmp_cb + tmp_sh * tmp_sp * tmp_sb;
 		Result[0][1] = tmp_sb * tmp_cp;
 		Result[0][2] = -tmp_sh * tmp_cb + tmp_ch * tmp_sp * tmp_sb;
@@ -236,8 +236,8 @@ namespace glm
 		return Result;
 	}
 
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat2x2<T, defaultp> orientate2
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, defaultp> orientate2
 	(
 		T const & angle
 	)
@@ -245,7 +245,7 @@ namespace glm
 		T c = glm::cos(angle);
 		T s = glm::sin(angle);
 
-		tmat2x2<T, defaultp> Result;
+		mat<2, 2, T, defaultp> Result;
 		Result[0][0] = c;
 		Result[0][1] = s;
 		Result[1][0] = -s;
@@ -253,8 +253,8 @@ namespace glm
 		return Result;
 	}
 
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat3x3<T, defaultp> orientate3
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, defaultp> orientate3
 	(
 		T const & angle
 	)
@@ -262,7 +262,7 @@ namespace glm
 		T c = glm::cos(angle);
 		T s = glm::sin(angle);
 
-		tmat3x3<T, defaultp> Result;
+		mat<3, 3, T, defaultp> Result;
 		Result[0][0] = c;
 		Result[0][1] = s;
 		Result[0][2] = 0.0f;
@@ -275,26 +275,26 @@ namespace glm
 		return Result;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x3<T, P> orientate3
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, P> orientate3
 	(
-		tvec3<T, P> const & angles
+		vec<3, T, P> const & angles
 	)
 	{
-		return tmat3x3<T, P>(yawPitchRoll(angles.z, angles.x, angles.y));
+		return mat<3, 3, T, P>(yawPitchRoll(angles.z, angles.x, angles.y));
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> orientate4
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, P> orientate4
 	(
-		tvec3<T, P> const & angles
+		vec<3, T, P> const & angles
 	)
 	{
 		return yawPitchRoll(angles.z, angles.x, angles.y);
 	}
     
-    template <typename T>
-    GLM_FUNC_DECL void extractEulerAngleXYZ(tmat4x4<T, defaultp> const & M,
+    template<typename T>
+    GLM_FUNC_DECL void extractEulerAngleXYZ(mat<4, 4, T, defaultp> const & M,
                                             T & t1,
                                             T & t2,
                                             T & t3)
diff --git a/glm/gtx/extend.hpp b/glm/gtx/extend.hpp
index ce42e4fe..aa752704 100644
--- a/glm/gtx/extend.hpp
+++ b/glm/gtx/extend.hpp
@@ -30,7 +30,7 @@ namespace glm
 
 	/// Extends of Length the Origin position using the (Source - Origin) direction.
 	/// @see gtx_extend
-	template <typename genType> 
+	template<typename genType> 
 	GLM_FUNC_DECL genType extend(
 		genType const & Origin, 
 		genType const & Source, 
diff --git a/glm/gtx/extend.inl b/glm/gtx/extend.inl
index 31555835..3939abd4 100644
--- a/glm/gtx/extend.inl
+++ b/glm/gtx/extend.inl
@@ -3,7 +3,7 @@
 
 namespace glm
 {
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER genType extend
 	(
 		genType const & Origin, 
@@ -14,33 +14,33 @@ namespace glm
 		return Origin + (Source - Origin) * Distance;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P> extend
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<2, T, P> extend
 	(
-		tvec2<T, P> const & Origin,
-		tvec2<T, P> const & Source,
+		vec<2, T, P> const & Origin,
+		vec<2, T, P> const & Source,
 		T const & Distance
 	)
 	{
 		return Origin + (Source - Origin) * Distance;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> extend
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> extend
 	(
-		tvec3<T, P> const & Origin,
-		tvec3<T, P> const & Source,
+		vec<3, T, P> const & Origin,
+		vec<3, T, P> const & Source,
 		T const & Distance
 	)
 	{
 		return Origin + (Source - Origin) * Distance;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> extend
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, T, P> extend
 	(
-		tvec4<T, P> const & Origin,
-		tvec4<T, P> const & Source,
+		vec<4, T, P> const & Origin,
+		vec<4, T, P> const & Source,
 		T const & Distance
 	)
 	{
diff --git a/glm/gtx/extended_min_max.hpp b/glm/gtx/extended_min_max.hpp
index 7bdb0897..537af0ce 100644
--- a/glm/gtx/extended_min_max.hpp
+++ b/glm/gtx/extended_min_max.hpp
@@ -30,7 +30,7 @@ namespace glm
 
 	/// Return the minimum component-wise values of 3 inputs 
 	/// @see gtx_extented_min_max
-	template <typename T>
+	template<typename T>
 	GLM_FUNC_DECL T min(
 		T const & x, 
 		T const & y, 
@@ -38,7 +38,7 @@ namespace glm
 
 	/// Return the minimum component-wise values of 3 inputs
 	/// @see gtx_extented_min_max
-	template <typename T, template <typename> class C>
+	template<typename T, template<typename> class C>
 	GLM_FUNC_DECL C<T> min(
 		C<T> const & x, 
 		typename C<T>::T const & y, 
@@ -46,7 +46,7 @@ namespace glm
 
 	/// Return the minimum component-wise values of 3 inputs 
 	/// @see gtx_extented_min_max
-	template <typename T, template <typename> class C>
+	template<typename T, template<typename> class C>
 	GLM_FUNC_DECL C<T> min(
 		C<T> const & x, 
 		C<T> const & y, 
@@ -54,7 +54,7 @@ namespace glm
 
 	/// Return the minimum component-wise values of 4 inputs 
 	/// @see gtx_extented_min_max
-	template <typename T>
+	template<typename T>
 	GLM_FUNC_DECL T min(
 		T const & x, 
 		T const & y, 
@@ -63,7 +63,7 @@ namespace glm
 
 	/// Return the minimum component-wise values of 4 inputs 
 	/// @see gtx_extented_min_max
-	template <typename T, template <typename> class C>
+	template<typename T, template<typename> class C>
 	GLM_FUNC_DECL C<T> min(
 		C<T> const & x, 
 		typename C<T>::T const & y, 
@@ -72,7 +72,7 @@ namespace glm
 
 	/// Return the minimum component-wise values of 4 inputs
 	/// @see gtx_extented_min_max
-	template <typename T, template <typename> class C>
+	template<typename T, template<typename> class C>
 	GLM_FUNC_DECL C<T> min(
 		C<T> const & x, 
 		C<T> const & y, 
@@ -81,7 +81,7 @@ namespace glm
 
 	/// Return the maximum component-wise values of 3 inputs 
 	/// @see gtx_extented_min_max
-	template <typename T>
+	template<typename T>
 	GLM_FUNC_DECL T max(
 		T const & x, 
 		T const & y, 
@@ -89,7 +89,7 @@ namespace glm
 
 	/// Return the maximum component-wise values of 3 inputs
 	/// @see gtx_extented_min_max
-	template <typename T, template <typename> class C>
+	template<typename T, template<typename> class C>
 	GLM_FUNC_DECL C<T> max(
 		C<T> const & x, 
 		typename C<T>::T const & y, 
@@ -97,7 +97,7 @@ namespace glm
 
 	/// Return the maximum component-wise values of 3 inputs 
 	/// @see gtx_extented_min_max
-	template <typename T, template <typename> class C>
+	template<typename T, template<typename> class C>
 	GLM_FUNC_DECL C<T> max(
 		C<T> const & x, 
 		C<T> const & y, 
@@ -105,7 +105,7 @@ namespace glm
 
 	/// Return the maximum component-wise values of 4 inputs
 	/// @see gtx_extented_min_max
-	template <typename T>
+	template<typename T>
 	GLM_FUNC_DECL T max(
 		T const & x, 
 		T const & y, 
@@ -114,7 +114,7 @@ namespace glm
 
 	/// Return the maximum component-wise values of 4 inputs 
 	/// @see gtx_extented_min_max
-	template <typename T, template <typename> class C>
+	template<typename T, template<typename> class C>
 	GLM_FUNC_DECL C<T> max(
 		C<T> const & x, 
 		typename C<T>::T const & y, 
@@ -123,7 +123,7 @@ namespace glm
 
 	/// Return the maximum component-wise values of 4 inputs 
 	/// @see gtx_extented_min_max
-	template <typename T, template <typename> class C>
+	template<typename T, template<typename> class C>
 	GLM_FUNC_DECL C<T> max(
 		C<T> const & x, 
 		C<T> const & y, 
diff --git a/glm/gtx/extended_min_max.inl b/glm/gtx/extended_min_max.inl
index 64ea4452..be09c93d 100644
--- a/glm/gtx/extended_min_max.inl
+++ b/glm/gtx/extended_min_max.inl
@@ -3,7 +3,7 @@
 
 namespace glm
 {
-	template <typename T>
+	template<typename T>
 	GLM_FUNC_QUALIFIER T min(
 		T const & x, 
 		T const & y, 
@@ -12,7 +12,7 @@ namespace glm
 		return glm::min(glm::min(x, y), z);
 	}
 
-	template <typename T, template <typename> class C>
+	template<typename T, template<typename> class C>
 	GLM_FUNC_QUALIFIER C<T> min
 	(
 		C<T> const & x, 
@@ -23,7 +23,7 @@ namespace glm
 		return glm::min(glm::min(x, y), z);
 	}
 
-	template <typename T, template <typename> class C>
+	template<typename T, template<typename> class C>
 	GLM_FUNC_QUALIFIER C<T> min
 	(
 		C<T> const & x, 
@@ -34,7 +34,7 @@ namespace glm
 		return glm::min(glm::min(x, y), z);
 	}
 
-	template <typename T>
+	template<typename T>
 	GLM_FUNC_QUALIFIER T min
 	(
 		T const & x, 
@@ -46,7 +46,7 @@ namespace glm
 		return glm::min(glm::min(x, y), glm::min(z, w));
 	}
 
-	template <typename T, template <typename> class C>
+	template<typename T, template<typename> class C>
 	GLM_FUNC_QUALIFIER C<T> min
 	(
 		C<T> const & x, 
@@ -58,7 +58,7 @@ namespace glm
 		return glm::min(glm::min(x, y), glm::min(z, w));
 	}
 
-	template <typename T, template <typename> class C>
+	template<typename T, template<typename> class C>
 	GLM_FUNC_QUALIFIER C<T> min
 	(
 		C<T> const & x, 
@@ -70,7 +70,7 @@ namespace glm
 		return glm::min(glm::min(x, y), glm::min(z, w));
 	}
 
-	template <typename T>
+	template<typename T>
 	GLM_FUNC_QUALIFIER T max(
 		T const & x, 
 		T const & y, 
@@ -79,7 +79,7 @@ namespace glm
 		return glm::max(glm::max(x, y), z);
 	}
 
-	template <typename T, template <typename> class C>
+	template<typename T, template<typename> class C>
 	GLM_FUNC_QUALIFIER C<T> max
 	(
 		C<T> const & x, 
@@ -90,7 +90,7 @@ namespace glm
 		return glm::max(glm::max(x, y), z);
 	}
 
-	template <typename T, template <typename> class C>
+	template<typename T, template<typename> class C>
 	GLM_FUNC_QUALIFIER C<T> max
 	(
 		C<T> const & x, 
@@ -101,7 +101,7 @@ namespace glm
 		return glm::max(glm::max(x, y), z);
 	}
 
-	template <typename T>
+	template<typename T>
 	GLM_FUNC_QUALIFIER T max
 	(
 		T const & x, 
@@ -113,7 +113,7 @@ namespace glm
 		return glm::max(glm::max(x, y), glm::max(z, w));
 	}
 
-	template <typename T, template <typename> class C>
+	template<typename T, template<typename> class C>
 	GLM_FUNC_QUALIFIER C<T> max
 	(
 		C<T> const & x, 
@@ -125,7 +125,7 @@ namespace glm
 		return glm::max(glm::max(x, y), glm::max(z, w));
 	}
 
-	template <typename T, template <typename> class C>
+	template<typename T, template<typename> class C>
 	GLM_FUNC_QUALIFIER C<T> max
 	(
 		C<T> const & x, 
diff --git a/glm/gtx/fast_exponential.hpp b/glm/gtx/fast_exponential.hpp
index 509745e3..80822c81 100644
--- a/glm/gtx/fast_exponential.hpp
+++ b/glm/gtx/fast_exponential.hpp
@@ -31,63 +31,63 @@ namespace glm
 
 	/// Faster than the common pow function but less accurate.
 	/// @see gtx_fast_exponential
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL genType fastPow(genType x, genType y);
 
 	/// Faster than the common pow function but less accurate.
 	/// @see gtx_fast_exponential
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> fastPow(vecType<T, P> const & x, vecType<T, P> const & y);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, T, P> fastPow(vecType<L, T, P> const & x, vecType<L, T, P> const & y);
 
 	/// Faster than the common pow function but less accurate.
 	/// @see gtx_fast_exponential
-	template <typename genTypeT, typename genTypeU>
+	template<typename genTypeT, typename genTypeU>
 	GLM_FUNC_DECL genTypeT fastPow(genTypeT x, genTypeU y);
 
 	/// Faster than the common pow function but less accurate.
 	/// @see gtx_fast_exponential
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> fastPow(vecType<T, P> const & x);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, T, P> fastPow(vecType<L, T, P> const & x);
 
 	/// Faster than the common exp function but less accurate.
 	/// @see gtx_fast_exponential
-	template <typename T>
+	template<typename T>
 	GLM_FUNC_DECL T fastExp(T x);
 
 	/// Faster than the common exp function but less accurate.
 	/// @see gtx_fast_exponential
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> fastExp(vecType<T, P> const & x);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, T, P> fastExp(vecType<L, T, P> const & x);
 
 	/// Faster than the common log function but less accurate.
 	/// @see gtx_fast_exponential
-	template <typename T>
+	template<typename T>
 	GLM_FUNC_DECL T fastLog(T x);
 
 	/// Faster than the common exp2 function but less accurate.
 	/// @see gtx_fast_exponential
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> fastLog(vecType<T, P> const & x);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, T, P> fastLog(vecType<L, T, P> const & x);
 
 	/// Faster than the common exp2 function but less accurate.
 	/// @see gtx_fast_exponential
-	template <typename T>
+	template<typename T>
 	GLM_FUNC_DECL T fastExp2(T x);
 
 	/// Faster than the common exp2 function but less accurate.
 	/// @see gtx_fast_exponential
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> fastExp2(vecType<T, P> const & x);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, T, P> fastExp2(vecType<L, T, P> const & x);
 
 	/// Faster than the common log2 function but less accurate.
 	/// @see gtx_fast_exponential
-	template <typename T>
+	template<typename T>
 	GLM_FUNC_DECL T fastLog2(T x);
 
 	/// Faster than the common log2 function but less accurate.
 	/// @see gtx_fast_exponential
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> fastLog2(vecType<T, P> const & x);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, T, P> fastLog2(vecType<L, T, P> const & x);
 
 	/// @}
 }//namespace glm
diff --git a/glm/gtx/fast_exponential.inl b/glm/gtx/fast_exponential.inl
index 72f9f8ff..54fcfcc9 100644
--- a/glm/gtx/fast_exponential.inl
+++ b/glm/gtx/fast_exponential.inl
@@ -4,19 +4,19 @@
 namespace glm
 {
 	// fastPow:
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER genType fastPow(genType x, genType y)
 	{
 		return exp(y * log(x));
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> fastPow(vecType<T, P> const & x, vecType<T, P> const & y)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> fastPow(vecType<L, T, P> const & x, vecType<L, T, P> const & y)
 	{
 		return exp(y * log(x));
 	}
 
-	template <typename T>
+	template<typename T>
 	GLM_FUNC_QUALIFIER T fastPow(T x, int y)
 	{
 		T f = static_cast<T>(1);
@@ -25,10 +25,10 @@ namespace glm
 		return f;
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> fastPow(vecType<T, P> const & x, vecType<int, P> const & y)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> fastPow(vecType<L, T, P> const & x, vecType<L, int, P> const & y)
 	{
-		vecType<T, P> Result(uninitialize);
+		vecType<L, T, P> Result(uninitialize);
 		for(length_t i = 0, n = x.length(); i < n; ++i)
 			Result[i] = fastPow(x[i], y[i]);
 		return Result;
@@ -36,7 +36,7 @@ namespace glm
 
 	// fastExp
 	// Note: This function provides accurate results only for value between -1 and 1, else avoid it.
-	template <typename T>
+	template<typename T>
 	GLM_FUNC_QUALIFIER T fastExp(T x)
 	{
 		// This has a better looking and same performance in release mode than the following code. However, in debug mode it's slower.
@@ -81,14 +81,14 @@ namespace glm
 	}
 	*/
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> fastExp(vecType<T, P> const & x)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> fastExp(vecType<L, T, P> const & x)
 	{
-		return detail::functor1<T, T, P, vecType>::call(fastExp, x);
+		return detail::functor1<L, T, T, P>::call(fastExp, x);
 	}
 
 	// fastLog
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER genType fastLog(genType x)
 	{
 		return std::log(x);
@@ -103,35 +103,35 @@ namespace glm
 	}
 	*/
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> fastLog(vecType<T, P> const & x)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> fastLog(vecType<L, T, P> const & x)
 	{
-		return detail::functor1<T, T, P, vecType>::call(fastLog, x);
+		return detail::functor1<L, T, T, P>::call(fastLog, x);
 	}
 
 	//fastExp2, ln2 = 0.69314718055994530941723212145818f
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER genType fastExp2(genType x)
 	{
 		return fastExp(0.69314718055994530941723212145818f * x);
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> fastExp2(vecType<T, P> const & x)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> fastExp2(vecType<L, T, P> const & x)
 	{
-		return detail::functor1<T, T, P, vecType>::call(fastExp2, x);
+		return detail::functor1<L, T, T, P>::call(fastExp2, x);
 	}
 
 	// fastLog2, ln2 = 0.69314718055994530941723212145818f
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER genType fastLog2(genType x)
 	{
 		return fastLog(x) / 0.69314718055994530941723212145818f;
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> fastLog2(vecType<T, P> const & x)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> fastLog2(vecType<L, T, P> const & x)
 	{
-		return detail::functor1<T, T, P, vecType>::call(fastLog2, x);
+		return detail::functor1<L, T, T, P>::call(fastLog2, x);
 	}
 }//namespace glm
diff --git a/glm/gtx/fast_square_root.hpp b/glm/gtx/fast_square_root.hpp
index ce72f40e..135829b0 100644
--- a/glm/gtx/fast_square_root.hpp
+++ b/glm/gtx/fast_square_root.hpp
@@ -35,55 +35,55 @@ namespace glm
 	/// Faster than the common sqrt function but less accurate.
 	///
 	/// @see gtx_fast_square_root extension.
-	template <typename genType> 
+	template<typename genType> 
 	GLM_FUNC_DECL genType fastSqrt(genType x);
 
 	/// Faster than the common sqrt function but less accurate.
 	///
 	/// @see gtx_fast_square_root extension.
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> fastSqrt(vecType<T, P> const & x);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, T, P> fastSqrt(vecType<L, T, P> const & x);
 
 	/// Faster than the common inversesqrt function but less accurate.
 	///
 	/// @see gtx_fast_square_root extension.
-	template <typename genType> 
+	template<typename genType> 
 	GLM_FUNC_DECL genType fastInverseSqrt(genType x);
 
 	/// Faster than the common inversesqrt function but less accurate.
 	///
 	/// @see gtx_fast_square_root extension.
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> fastInverseSqrt(vecType<T, P> const & x);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, T, P> fastInverseSqrt(vecType<L, T, P> const & x);
 
 	/// Faster than the common length function but less accurate.
 	///
 	/// @see gtx_fast_square_root extension.
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL genType fastLength(genType x);
 
 	/// Faster than the common length function but less accurate.
 	///
 	/// @see gtx_fast_square_root extension.
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL T fastLength(vecType<T, P> const & x);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL T fastLength(vecType<L, T, P> const & x);
 
 	/// Faster than the common distance function but less accurate.
 	///
 	/// @see gtx_fast_square_root extension.
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL genType fastDistance(genType x, genType y);
 
 	/// Faster than the common distance function but less accurate.
 	///
 	/// @see gtx_fast_square_root extension.
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL T fastDistance(vecType<T, P> const & x, vecType<T, P> const & y);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL T fastDistance(vecType<L, T, P> const & x, vecType<L, T, P> const & y);
 
 	/// Faster than the common normalize function but less accurate.
 	///
 	/// @see gtx_fast_square_root extension.
-	template <typename genType> 
+	template<typename genType> 
 	GLM_FUNC_DECL genType fastNormalize(genType const & x);
 
 	/// @}
diff --git a/glm/gtx/fast_square_root.inl b/glm/gtx/fast_square_root.inl
index 73950aec..846659ab 100644
--- a/glm/gtx/fast_square_root.inl
+++ b/glm/gtx/fast_square_root.inl
@@ -4,7 +4,7 @@
 namespace glm
 {
 	// fastSqrt
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER genType fastSqrt(genType x)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'fastSqrt' only accept floating-point input");
@@ -12,32 +12,32 @@ namespace glm
 		return genType(1) / fastInverseSqrt(x);
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> fastSqrt(vecType<T, P> const & x)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> fastSqrt(vecType<L, T, P> const & x)
 	{
-		return detail::functor1<T, T, P, vecType>::call(fastSqrt, x);
+		return detail::functor1<L, T, T, P>::call(fastSqrt, x);
 	}
 
 	// fastInversesqrt
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER genType fastInverseSqrt(genType x)
 	{
 #		ifdef __CUDACC__ // Wordaround for a CUDA compiler bug up to CUDA6
-			tvec1<T, P> tmp(detail::compute_inversesqrt<tvec1, genType, lowp, detail::is_aligned<lowp>::value>::call(tvec1<genType, lowp>(x)));
+			vec<1, T, P> tmp(detail::compute_inversesqrt<tvec1, genType, lowp, detail::is_aligned<lowp>::value>::call(vec<1, genType, lowp>(x)));
 			return tmp.x;
 #		else
-			return detail::compute_inversesqrt<tvec1, genType, highp, detail::is_aligned<highp>::value>::call(tvec1<genType, lowp>(x)).x;
+			return detail::compute_inversesqrt<1, genType, highp, detail::is_aligned<highp>::value>::call(vec<1, genType, lowp>(x)).x;
 #		endif
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> fastInverseSqrt(vecType<T, P> const & x)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> fastInverseSqrt(vecType<L, T, P> const & x)
 	{
-		return detail::compute_inversesqrt<vecType, T, P, detail::is_aligned<P>::value>::call(x);
+		return detail::compute_inversesqrt<L, T, P, detail::is_aligned<P>::value>::call(x);
 	}
 
 	// fastLength
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER genType fastLength(genType x)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'fastLength' only accept floating-point inputs");
@@ -45,8 +45,8 @@ namespace glm
 		return abs(x);
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER T fastLength(vecType<T, P> const & x)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER T fastLength(vecType<L, T, P> const & x)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'fastLength' only accept floating-point inputs");
 
@@ -54,27 +54,27 @@ namespace glm
 	}
 
 	// fastDistance
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER genType fastDistance(genType x, genType y)
 	{
 		return fastLength(y - x);
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER T fastDistance(vecType<T, P> const & x, vecType<T, P> const & y)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER T fastDistance(vecType<L, T, P> const & x, vecType<L, T, P> const & y)
 	{
 		return fastLength(y - x);
 	}
 
 	// fastNormalize
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER genType fastNormalize(genType x)
 	{
 		return x > genType(0) ? genType(1) : -genType(1);
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> fastNormalize(vecType<T, P> const & x)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> fastNormalize(vecType<L, T, P> const & x)
 	{
 		return x * fastInverseSqrt(dot(x, x));
 	}
diff --git a/glm/gtx/fast_trigonometry.hpp b/glm/gtx/fast_trigonometry.hpp
index 1a1dc6e1..d78de725 100644
--- a/glm/gtx/fast_trigonometry.hpp
+++ b/glm/gtx/fast_trigonometry.hpp
@@ -30,47 +30,47 @@ namespace glm
 
 	/// Wrap an angle to [0 2pi[
 	/// From GLM_GTX_fast_trigonometry extension.
-	template <typename T> 
+	template<typename T> 
 	GLM_FUNC_DECL T wrapAngle(T angle);
 
 	/// Faster than the common sin function but less accurate.
 	/// From GLM_GTX_fast_trigonometry extension.
-	template <typename T>
+	template<typename T>
 	GLM_FUNC_DECL T fastSin(T angle);
 
 	/// Faster than the common cos function but less accurate.
 	/// From GLM_GTX_fast_trigonometry extension.
-	template <typename T> 
+	template<typename T> 
 	GLM_FUNC_DECL T fastCos(T angle);
 
 	/// Faster than the common tan function but less accurate. 
 	/// Defined between -2pi and 2pi. 
 	/// From GLM_GTX_fast_trigonometry extension.
-	template <typename T> 
+	template<typename T> 
 	GLM_FUNC_DECL T fastTan(T angle);
 
 	/// Faster than the common asin function but less accurate. 
 	/// Defined between -2pi and 2pi.
 	/// From GLM_GTX_fast_trigonometry extension.
-	template <typename T> 
+	template<typename T> 
 	GLM_FUNC_DECL T fastAsin(T angle);
 
 	/// Faster than the common acos function but less accurate. 
 	/// Defined between -2pi and 2pi. 
 	/// From GLM_GTX_fast_trigonometry extension.
-	template <typename T> 
+	template<typename T> 
 	GLM_FUNC_DECL T fastAcos(T angle);
 
 	/// Faster than the common atan function but less accurate.
 	/// Defined between -2pi and 2pi. 
 	/// From GLM_GTX_fast_trigonometry extension.
-	template <typename T> 
+	template<typename T> 
 	GLM_FUNC_DECL T fastAtan(T y, T x);
 
 	/// Faster than the common atan function but less accurate. 
 	/// Defined between -2pi and 2pi.
 	/// From GLM_GTX_fast_trigonometry extension.
-	template <typename T> 
+	template<typename T> 
 	GLM_FUNC_DECL T fastAtan(T angle);
 
 	/// @}
diff --git a/glm/gtx/fast_trigonometry.inl b/glm/gtx/fast_trigonometry.inl
index f459d854..200c371b 100644
--- a/glm/gtx/fast_trigonometry.inl
+++ b/glm/gtx/fast_trigonometry.inl
@@ -4,8 +4,8 @@
 namespace glm{
 namespace detail
 {
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> taylorCos(vecType<T, P> const & x)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> taylorCos(vecType<L, T, P> const & x)
 	{
 		return static_cast<T>(1)
 			- (x * x) * (1.f / 2.f)
@@ -14,35 +14,35 @@ namespace detail
 			+ (((x * x) * (x * x)) * ((x * x) * (x * x))) * (1.f / 40320.f);
 	}
 
-	template <typename T>
+	template<typename T>
 	GLM_FUNC_QUALIFIER T cos_52s(T x)
 	{
 		T const xx(x * x);
 		return (T(0.9999932946) + xx * (T(-0.4999124376) + xx * (T(0.0414877472) + xx * T(-0.0012712095))));
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> cos_52s(vecType<T, P> const & x)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> cos_52s(vecType<L, T, P> const & x)
 	{
-		return detail::functor1<T, T, P, vecType>::call(cos_52s, x);
+		return detail::functor1<L, T, T, P>::call(cos_52s, x);
 	}
 }//namespace detail
 
 	// wrapAngle
-	template <typename T>
+	template<typename T>
 	GLM_FUNC_QUALIFIER T wrapAngle(T angle)
 	{
 		return abs<T>(mod<T>(angle, two_pi<T>()));
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> wrapAngle(vecType<T, P> const & x)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> wrapAngle(vecType<L, T, P> const & x)
 	{
-		return detail::functor1<T, T, P, vecType>::call(wrapAngle, x);
+		return detail::functor1<L, T, T, P>::call(wrapAngle, x);
 	}
 
 	// cos
-	template <typename T> 
+	template<typename T> 
 	GLM_FUNC_QUALIFIER T fastCos(T x)
 	{
 		T const angle(wrapAngle<T>(x));
@@ -57,87 +57,87 @@ namespace detail
 		return detail::cos_52s(two_pi<T>() - angle);
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> fastCos(vecType<T, P> const & x)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> fastCos(vecType<L, T, P> const & x)
 	{
-		return detail::functor1<T, T, P, vecType>::call(fastCos, x);
+		return detail::functor1<L, T, T, P>::call(fastCos, x);
 	}
 
 	// sin
-	template <typename T> 
+	template<typename T> 
 	GLM_FUNC_QUALIFIER T fastSin(T x)
 	{
 		return fastCos<T>(half_pi<T>() - x);
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> fastSin(vecType<T, P> const & x)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> fastSin(vecType<L, T, P> const & x)
 	{
-		return detail::functor1<T, T, P, vecType>::call(fastSin, x);
+		return detail::functor1<L, T, T, P>::call(fastSin, x);
 	}
 
 	// tan
-	template <typename T> 
+	template<typename T> 
 	GLM_FUNC_QUALIFIER T fastTan(T x)
 	{
 		return x + (x * x * x * T(0.3333333333)) + (x * x * x * x * x * T(0.1333333333333)) + (x * x * x * x * x * x * x * T(0.0539682539));
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> fastTan(vecType<T, P> const & x)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> fastTan(vecType<L, T, P> const & x)
 	{
-		return detail::functor1<T, T, P, vecType>::call(fastTan, x);
+		return detail::functor1<L, T, T, P>::call(fastTan, x);
 	}
 
 	// asin
-	template <typename T> 
+	template<typename T> 
 	GLM_FUNC_QUALIFIER T fastAsin(T x)
 	{
 		return x + (x * x * x * T(0.166666667)) + (x * x * x * x * x * T(0.075)) + (x * x * x * x * x * x * x * T(0.0446428571)) + (x * x * x * x * x * x * x * x * x * T(0.0303819444));// + (x * x * x * x * x * x * x * x * x * x * x * T(0.022372159));
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> fastAsin(vecType<T, P> const & x)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> fastAsin(vecType<L, T, P> const & x)
 	{
-		return detail::functor1<T, T, P, vecType>::call(fastAsin, x);
+		return detail::functor1<L, T, T, P>::call(fastAsin, x);
 	}
 
 	// acos
-	template <typename T> 
+	template<typename T> 
 	GLM_FUNC_QUALIFIER T fastAcos(T x)
 	{
 		return T(1.5707963267948966192313216916398) - fastAsin(x); //(PI / 2)
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> fastAcos(vecType<T, P> const & x)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> fastAcos(vecType<L, T, P> const & x)
 	{
-		return detail::functor1<T, T, P, vecType>::call(fastAcos, x);
+		return detail::functor1<L, T, T, P>::call(fastAcos, x);
 	}
 
 	// atan
-	template <typename T> 
+	template<typename T> 
 	GLM_FUNC_QUALIFIER T fastAtan(T y, T x)
 	{
 		T sgn = sign(y) * sign(x);
 		return abs(fastAtan(y / x)) * sgn;
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> fastAtan(vecType<T, P> const & y, vecType<T, P> const & x)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> fastAtan(vecType<L, T, P> const & y, vecType<L, T, P> const & x)
 	{
-		return detail::functor2<T, P, vecType>::call(fastAtan, y, x);
+		return detail::functor2<L, T, P>::call(fastAtan, y, x);
 	}
 
-	template <typename T> 
+	template<typename T> 
 	GLM_FUNC_QUALIFIER T fastAtan(T x)
 	{
 		return x - (x * x * x * T(0.333333333333)) + (x * x * x * x * x * T(0.2)) - (x * x * x * x * x * x * x * T(0.1428571429)) + (x * x * x * x * x * x * x * x * x * T(0.111111111111)) - (x * x * x * x * x * x * x * x * x * x * x * T(0.0909090909));
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> fastAtan(vecType<T, P> const & x)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> fastAtan(vecType<L, T, P> const & x)
 	{
-		return detail::functor1<T, T, P, vecType>::call(fastAtan, x);
+		return detail::functor1<L, T, T, P>::call(fastAtan, x);
 	}
 }//namespace glm
diff --git a/glm/gtx/float_notmalize.inl b/glm/gtx/float_notmalize.inl
index 4dde0256..665e2fbd 100644
--- a/glm/gtx/float_notmalize.inl
+++ b/glm/gtx/float_notmalize.inl
@@ -5,10 +5,10 @@
 
 namespace glm
 {
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<float, P> floatNormalize(vecType<T, P> const & v)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, float, P> floatNormalize(vecType<L, T, P> const & v)
 	{
-		return vecType<float, P>(v) / static_cast<float>(std::numeric_limits<T>::max());
+		return vecType<L, float, P>(v) / static_cast<float>(std::numeric_limits<T>::max());
 	}
 
 }//namespace glm
diff --git a/glm/gtx/gradient_paint.hpp b/glm/gtx/gradient_paint.hpp
index cf843d71..50a930dd 100644
--- a/glm/gtx/gradient_paint.hpp
+++ b/glm/gtx/gradient_paint.hpp
@@ -31,20 +31,20 @@ namespace glm
 
 	/// Return a color from a radial gradient.
 	/// @see - gtx_gradient_paint
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_DECL T radialGradient(
-		tvec2<T, P> const & Center,
+		vec<2, T, P> const & Center,
 		T const & Radius,
-		tvec2<T, P> const & Focal,
-		tvec2<T, P> const & Position);
+		vec<2, T, P> const & Focal,
+		vec<2, T, P> const & Position);
 
 	/// Return a color from a linear gradient.
 	/// @see - gtx_gradient_paint
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_DECL T linearGradient(
-		tvec2<T, P> const & Point0,
-		tvec2<T, P> const & Point1,
-		tvec2<T, P> const & Position);
+		vec<2, T, P> const & Point0,
+		vec<2, T, P> const & Point1,
+		vec<2, T, P> const & Position);
 
 	/// @}
 }// namespace glm
diff --git a/glm/gtx/gradient_paint.inl b/glm/gtx/gradient_paint.inl
index aaa5ce14..ef8b7e4e 100644
--- a/glm/gtx/gradient_paint.inl
+++ b/glm/gtx/gradient_paint.inl
@@ -3,17 +3,17 @@
 
 namespace glm
 {
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER T radialGradient
 	(
-		tvec2<T, P> const & Center,
+		vec<2, T, P> const & Center,
 		T const & Radius,
-		tvec2<T, P> const & Focal,
-		tvec2<T, P> const & Position
+		vec<2, T, P> const & Focal,
+		vec<2, T, P> const & Position
 	)
 	{
-		tvec2<T, P> F = Focal - Center;
-		tvec2<T, P> D = Position - Focal;
+		vec<2, T, P> F = Focal - Center;
+		vec<2, T, P> D = Position - Focal;
 		T Radius2 = pow2(Radius);
 		T Fx2 = pow2(F.x);
 		T Fy2 = pow2(F.y);
@@ -23,15 +23,15 @@ namespace glm
 		return Numerator / Denominator;
 	}
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER T linearGradient
 	(
-		tvec2<T, P> const & Point0,
-		tvec2<T, P> const & Point1,
-		tvec2<T, P> const & Position
+		vec<2, T, P> const & Point0,
+		vec<2, T, P> const & Point1,
+		vec<2, T, P> const & Position
 	)
 	{
-		tvec2<T, P> Dist = Point1 - Point0;
+		vec<2, T, P> Dist = Point1 - Point0;
 		return (Dist.x * (Position.x - Point0.x) + Dist.y * (Position.y - Point0.y)) / glm::dot(Dist, Dist);
 	}
 }//namespace glm
diff --git a/glm/gtx/handed_coordinate_space.hpp b/glm/gtx/handed_coordinate_space.hpp
index cc01fcaf..61491940 100644
--- a/glm/gtx/handed_coordinate_space.hpp
+++ b/glm/gtx/handed_coordinate_space.hpp
@@ -30,19 +30,19 @@ namespace glm
 
 	//! Return if a trihedron right handed or not.
 	//! From GLM_GTX_handed_coordinate_space extension.
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_DECL bool rightHanded(
-		tvec3<T, P> const & tangent,
-		tvec3<T, P> const & binormal,
-		tvec3<T, P> const & normal);
+		vec<3, T, P> const & tangent,
+		vec<3, T, P> const & binormal,
+		vec<3, T, P> const & normal);
 
 	//! Return if a trihedron left handed or not.
 	//! From GLM_GTX_handed_coordinate_space extension.
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_DECL bool leftHanded(
-		tvec3<T, P> const & tangent,
-		tvec3<T, P> const & binormal,
-		tvec3<T, P> const & normal);
+		vec<3, T, P> const & tangent,
+		vec<3, T, P> const & binormal,
+		vec<3, T, P> const & normal);
 
 	/// @}
 }// namespace glm
diff --git a/glm/gtx/handed_coordinate_space.inl b/glm/gtx/handed_coordinate_space.inl
index 2e55653c..d95fcd08 100644
--- a/glm/gtx/handed_coordinate_space.inl
+++ b/glm/gtx/handed_coordinate_space.inl
@@ -3,23 +3,23 @@
 
 namespace glm
 {
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER bool rightHanded
 	(
-		tvec3<T, P> const & tangent,
-		tvec3<T, P> const & binormal,
-		tvec3<T, P> const & normal
+		vec<3, T, P> const & tangent,
+		vec<3, T, P> const & binormal,
+		vec<3, T, P> const & normal
 	)
 	{
 		return dot(cross(normal, tangent), binormal) > T(0);
 	}
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER bool leftHanded
 	(
-		tvec3<T, P> const & tangent,
-		tvec3<T, P> const & binormal,
-		tvec3<T, P> const & normal
+		vec<3, T, P> const & tangent,
+		vec<3, T, P> const & binormal,
+		vec<3, T, P> const & normal
 	)
 	{
 		return dot(cross(normal, tangent), binormal) < T(0);
diff --git a/glm/gtx/hash.hpp b/glm/gtx/hash.hpp
index 5858d4ba..d457e99a 100644
--- a/glm/gtx/hash.hpp
+++ b/glm/gtx/hash.hpp
@@ -44,94 +44,94 @@
 
 namespace std
 {
-	template <typename T, glm::precision P>
-	struct hash<glm::tvec1<T,P> >
+	template<typename T, glm::precision P>
+	struct hash<glm::vec<1, T,P> >
 	{
-		GLM_FUNC_DECL size_t operator()(glm::tvec1<T, P> const & v) const;
+		GLM_FUNC_DECL size_t operator()(glm::vec<1, T, P> const & v) const;
 	};
 
-	template <typename T, glm::precision P>
-	struct hash<glm::tvec2<T,P> >
+	template<typename T, glm::precision P>
+	struct hash<glm::vec<2, T,P> >
 	{
-		GLM_FUNC_DECL size_t operator()(glm::tvec2<T, P> const & v) const;
+		GLM_FUNC_DECL size_t operator()(glm::vec<2, T, P> const & v) const;
 	};
 
-	template <typename T, glm::precision P>
-	struct hash<glm::tvec3<T,P> >
+	template<typename T, glm::precision P>
+	struct hash<glm::vec<3, T,P> >
 	{
-		GLM_FUNC_DECL size_t operator()(glm::tvec3<T, P> const & v) const;
+		GLM_FUNC_DECL size_t operator()(glm::vec<3, T, P> const & v) const;
 	};
 
-	template <typename T, glm::precision P>
-	struct hash<glm::tvec4<T,P> >
+	template<typename T, glm::precision P>
+	struct hash<glm::vec<4, T,P> >
 	{
-		GLM_FUNC_DECL size_t operator()(glm::tvec4<T, P> const & v) const;
+		GLM_FUNC_DECL size_t operator()(glm::vec<4, T, P> const & v) const;
 	};
 
-	template <typename T, glm::precision P>
+	template<typename T, glm::precision P>
 	struct hash<glm::tquat<T,P>>
 	{
 		GLM_FUNC_DECL size_t operator()(glm::tquat<T, P> const & q) const;
 	};
 
-	template <typename T, glm::precision P>
+	template<typename T, glm::precision P>
 	struct hash<glm::tdualquat<T,P> >
 	{
 		GLM_FUNC_DECL size_t operator()(glm::tdualquat<T,P> const & q) const;
 	};
 
-	template <typename T, glm::precision P>
-	struct hash<glm::tmat2x2<T,P> >
+	template<typename T, glm::precision P>
+	struct hash<glm::mat<2, 2, T,P> >
 	{
-		GLM_FUNC_DECL size_t operator()(glm::tmat2x2<T,P> const & m) const;
+		GLM_FUNC_DECL size_t operator()(glm::mat<2, 2, T,P> const & m) const;
 	};
 
-	template <typename T, glm::precision P>
-	struct hash<glm::tmat2x3<T,P> >
+	template<typename T, glm::precision P>
+	struct hash<glm::mat<2, 3, T,P> >
 	{
-		GLM_FUNC_DECL size_t operator()(glm::tmat2x3<T,P> const & m) const;
+		GLM_FUNC_DECL size_t operator()(glm::mat<2, 3, T,P> const & m) const;
 	};
 
-	template <typename T, glm::precision P>
-	struct hash<glm::tmat2x4<T,P> >
+	template<typename T, glm::precision P>
+	struct hash<glm::mat<2, 4, T,P> >
 	{
-		GLM_FUNC_DECL size_t operator()(glm::tmat2x4<T,P> const & m) const;
+		GLM_FUNC_DECL size_t operator()(glm::mat<2, 4, T,P> const & m) const;
 	};
 
-	template <typename T, glm::precision P>
-	struct hash<glm::tmat3x2<T,P> >
+	template<typename T, glm::precision P>
+	struct hash<glm::mat<3, 2, T,P> >
 	{
-		GLM_FUNC_DECL size_t operator()(glm::tmat3x2<T,P> const & m) const;
+		GLM_FUNC_DECL size_t operator()(glm::mat<3, 2, T,P> const & m) const;
 	};
 
-	template <typename T, glm::precision P>
-	struct hash<glm::tmat3x3<T,P> >
+	template<typename T, glm::precision P>
+	struct hash<glm::mat<3, 3, T,P> >
 	{
-		GLM_FUNC_DECL size_t operator()(glm::tmat3x3<T,P> const & m) const;
+		GLM_FUNC_DECL size_t operator()(glm::mat<3, 3, T,P> const & m) const;
 	};
 
-	template <typename T, glm::precision P>
-	struct hash<glm::tmat3x4<T,P> >
+	template<typename T, glm::precision P>
+	struct hash<glm::mat<3, 4, T,P> >
 	{
-		GLM_FUNC_DECL size_t operator()(glm::tmat3x4<T,P> const & m) const;
+		GLM_FUNC_DECL size_t operator()(glm::mat<3, 4, T,P> const & m) const;
 	};
 
-	template <typename T, glm::precision P>
-	struct hash<glm::tmat4x2<T,P> >
+	template<typename T, glm::precision P>
+	struct hash<glm::mat<4, 2, T,P> >
 	{
-		GLM_FUNC_DECL size_t operator()(glm::tmat4x2<T,P> const & m) const;
+		GLM_FUNC_DECL size_t operator()(glm::mat<4, 2, T,P> const & m) const;
 	};
 	
-	template <typename T, glm::precision P>
-	struct hash<glm::tmat4x3<T,P> >
+	template<typename T, glm::precision P>
+	struct hash<glm::mat<4, 3, T,P> >
 	{
-		GLM_FUNC_DECL size_t operator()(glm::tmat4x3<T,P> const & m) const;
+		GLM_FUNC_DECL size_t operator()(glm::mat<4, 3, T,P> const & m) const;
 	};
 
-	template <typename T, glm::precision P>
-	struct hash<glm::tmat4x4<T,P> >
+	template<typename T, glm::precision P>
+	struct hash<glm::mat<4, 4, T,P> >
 	{
-		GLM_FUNC_DECL size_t operator()(glm::tmat4x4<T,P> const & m) const;
+		GLM_FUNC_DECL size_t operator()(glm::mat<4, 4, T,P> const & m) const;
 	};
 } // namespace std
 
diff --git a/glm/gtx/hash.inl b/glm/gtx/hash.inl
index c42f4f0a..1e1e72ff 100644
--- a/glm/gtx/hash.inl
+++ b/glm/gtx/hash.inl
@@ -22,15 +22,15 @@ namespace detail
 
 namespace std
 {
-	template <typename T, glm::precision P>
-	GLM_FUNC_QUALIFIER size_t hash<glm::tvec1<T, P>>::operator()(glm::tvec1<T, P> const & v) const
+	template<typename T, glm::precision P>
+	GLM_FUNC_QUALIFIER size_t hash<glm::vec<1, T, P>>::operator()(glm::vec<1, T, P> const & v) const
 	{
 		hash<T> hasher;
 		return hasher(v.x);
 	}
 
-	template <typename T, glm::precision P>
-	GLM_FUNC_QUALIFIER size_t hash<glm::tvec2<T, P>>::operator()(glm::tvec2<T, P> const & v) const
+	template<typename T, glm::precision P>
+	GLM_FUNC_QUALIFIER size_t hash<glm::vec<2, T, P>>::operator()(glm::vec<2, T, P> const & v) const
 	{
 		size_t seed = 0;
 		hash<T> hasher;
@@ -39,8 +39,8 @@ namespace std
 		return seed;
 	}
 
-	template <typename T, glm::precision P>
-	GLM_FUNC_QUALIFIER size_t hash<glm::tvec3<T, P>>::operator()(glm::tvec3<T, P> const & v) const
+	template<typename T, glm::precision P>
+	GLM_FUNC_QUALIFIER size_t hash<glm::vec<3, T, P>>::operator()(glm::vec<3, T, P> const & v) const
 	{
 		size_t seed = 0;
 		hash<T> hasher;
@@ -50,8 +50,8 @@ namespace std
 		return seed;
 	}
 
-	template <typename T, glm::precision P>
-	GLM_FUNC_QUALIFIER size_t hash<glm::tvec4<T, P>>::operator()(glm::tvec4<T, P> const & v) const
+	template<typename T, glm::precision P>
+	GLM_FUNC_QUALIFIER size_t hash<glm::vec<4, T, P>>::operator()(glm::vec<4, T, P> const & v) const
 	{
 		size_t seed = 0;
 		hash<T> hasher;
@@ -62,7 +62,7 @@ namespace std
 		return seed;
 	}
 
-	template <typename T, glm::precision P>
+	template<typename T, glm::precision P>
 	GLM_FUNC_QUALIFIER size_t hash<glm::tquat<T, P>>::operator()(glm::tquat<T,P> const & q) const
 	{
 		size_t seed = 0;
@@ -74,7 +74,7 @@ namespace std
 		return seed;
 	}
 
-	template <typename T, glm::precision P>
+	template<typename T, glm::precision P>
 	GLM_FUNC_QUALIFIER size_t hash<glm::tdualquat<T, P>>::operator()(glm::tdualquat<T, P> const & q) const
 	{
 		size_t seed = 0;
@@ -84,74 +84,74 @@ namespace std
 		return seed;
 	}
 
-	template <typename T, glm::precision P>
-	GLM_FUNC_QUALIFIER size_t hash<glm::tmat2x2<T, P>>::operator()(glm::tmat2x2<T, P> const & m) const
+	template<typename T, glm::precision P>
+	GLM_FUNC_QUALIFIER size_t hash<glm::mat<2, 2, T, P>>::operator()(glm::mat<2, 2, T, P> const& m) const
 	{
 		size_t seed = 0;
-		hash<glm::tvec2<T, P>> hasher;
+		hash<glm::vec<2, T, P>> hasher;
 		glm::detail::hash_combine(seed, hasher(m[0]));
 		glm::detail::hash_combine(seed, hasher(m[1]));
 		return seed;
 	}
 
-	template <typename T, glm::precision P>
-	GLM_FUNC_QUALIFIER size_t hash<glm::tmat2x3<T, P>>::operator()(glm::tmat2x3<T, P> const & m) const
+	template<typename T, glm::precision P>
+	GLM_FUNC_QUALIFIER size_t hash<glm::mat<2, 3, T, P>>::operator()(glm::mat<2, 3, T, P> const& m) const
 	{
 		size_t seed = 0;
-		hash<glm::tvec3<T, P>> hasher;
+		hash<glm::vec<3, T, P>> hasher;
 		glm::detail::hash_combine(seed, hasher(m[0]));
 		glm::detail::hash_combine(seed, hasher(m[1]));
 		return seed;
 	}
 
-	template <typename T, glm::precision P>
-	GLM_FUNC_QUALIFIER size_t hash<glm::tmat2x4<T, P>>::operator()(glm::tmat2x4<T, P> const & m) const
+	template<typename T, glm::precision P>
+	GLM_FUNC_QUALIFIER size_t hash<glm::mat<2, 4, T, P>>::operator()(glm::mat<2, 4, T, P> const& m) const
 	{
 		size_t seed = 0;
-		hash<glm::tvec4<T, P>> hasher;
+		hash<glm::vec<4, T, P>> hasher;
 		glm::detail::hash_combine(seed, hasher(m[0]));
 		glm::detail::hash_combine(seed, hasher(m[1]));
 		return seed;
 	}
 
-	template <typename T, glm::precision P>
-	GLM_FUNC_QUALIFIER size_t hash<glm::tmat3x2<T, P>>::operator()(glm::tmat3x2<T, P> const & m) const
+	template<typename T, glm::precision P>
+	GLM_FUNC_QUALIFIER size_t hash<glm::mat<3, 2, T, P>>::operator()(glm::mat<3, 2, T, P> const& m) const
 	{
 		size_t seed = 0;
-		hash<glm::tvec2<T, P>> hasher;
+		hash<glm::vec<2, T, P>> hasher;
 		glm::detail::hash_combine(seed, hasher(m[0]));
 		glm::detail::hash_combine(seed, hasher(m[1]));
 		glm::detail::hash_combine(seed, hasher(m[2]));
 		return seed;
 	}
 
-	template <typename T, glm::precision P>
-	GLM_FUNC_QUALIFIER size_t hash<glm::tmat3x3<T, P>>::operator()(glm::tmat3x3<T, P> const & m) const
+	template<typename T, glm::precision P>
+	GLM_FUNC_QUALIFIER size_t hash<glm::mat<3, 3, T, P>>::operator()(glm::mat<3, 3, T, P> const& m) const
 	{
 		size_t seed = 0;
-		hash<glm::tvec3<T, P>> hasher;
+		hash<glm::vec<3, T, P>> hasher;
 		glm::detail::hash_combine(seed, hasher(m[0]));
 		glm::detail::hash_combine(seed, hasher(m[1]));
 		glm::detail::hash_combine(seed, hasher(m[2]));
 		return seed;
 	}
 
-	template <typename T, glm::precision P>
-	GLM_FUNC_QUALIFIER size_t hash<glm::tmat3x4<T, P>>::operator()(glm::tmat3x4<T, P> const & m) const
+	template<typename T, glm::precision P>
+	GLM_FUNC_QUALIFIER size_t hash<glm::mat<3, 4, T, P>>::operator()(glm::mat<3, 4, T, P> const& m) const
 	{
 		size_t seed = 0;
-		hash<glm::tvec4<T, P>> hasher;
+		hash<glm::vec<4, T, P>> hasher;
 		glm::detail::hash_combine(seed, hasher(m[0]));
 		glm::detail::hash_combine(seed, hasher(m[1]));
 		glm::detail::hash_combine(seed, hasher(m[2]));
 		return seed;
 	}
 
-	template <typename T, glm::precision P>
-	GLM_FUNC_QUALIFIER size_t hash<glm::tmat4x2<T,P>>::operator()(glm::tmat4x2<T,P> const & m) const
+	template<typename T, glm::precision P>
+	GLM_FUNC_QUALIFIER size_t hash<glm::mat<4, 2, T,P>>::operator()(glm::mat<4, 2, T,P> const & m) const
 	{
 		size_t seed = 0;
-		hash<glm::tvec2<T, P>> hasher;
+		hash<glm::vec<2, T, P>> hasher;
 		glm::detail::hash_combine(seed, hasher(m[0]));
 		glm::detail::hash_combine(seed, hasher(m[1]));
 		glm::detail::hash_combine(seed, hasher(m[2]));
@@ -159,11 +159,11 @@ namespace std
 		return seed;
 	}
 
-	template <typename T, glm::precision P>
-	GLM_FUNC_QUALIFIER size_t hash<glm::tmat4x3<T,P>>::operator()(glm::tmat4x3<T,P> const & m) const
+	template<typename T, glm::precision P>
+	GLM_FUNC_QUALIFIER size_t hash<glm::mat<4, 3, T,P>>::operator()(glm::mat<4, 3, T,P> const & m) const
 	{
 		size_t seed = 0;
-		hash<glm::tvec3<T, P>> hasher;
+		hash<glm::vec<3, T, P>> hasher;
 		glm::detail::hash_combine(seed, hasher(m[0]));
 		glm::detail::hash_combine(seed, hasher(m[1]));
 		glm::detail::hash_combine(seed, hasher(m[2]));
@@ -171,11 +171,11 @@ namespace std
 		return seed;
 	}
 
-	template <typename T, glm::precision P>
-	GLM_FUNC_QUALIFIER size_t hash<glm::tmat4x4<T,P>>::operator()(glm::tmat4x4<T, P> const & m) const
+	template<typename T, glm::precision P>
+	GLM_FUNC_QUALIFIER size_t hash<glm::mat<4, 4, T,P>>::operator()(glm::mat<4, 4, T, P> const& m) const
 	{
 		size_t seed = 0;
-		hash<glm::tvec4<T, P>> hasher;
+		hash<glm::vec<4, T, P>> hasher;
 		glm::detail::hash_combine(seed, hasher(m[0]));
 		glm::detail::hash_combine(seed, hasher(m[1]));
 		glm::detail::hash_combine(seed, hasher(m[2]));
diff --git a/glm/gtx/integer.hpp b/glm/gtx/integer.hpp
index da6b8fe2..d96b3d82 100644
--- a/glm/gtx/integer.hpp
+++ b/glm/gtx/integer.hpp
@@ -47,7 +47,7 @@ namespace glm
 
 	//! Return the factorial value of a number (!12 max, integer only)
 	//! From GLM_GTX_integer extension.
-	template <typename genType> 
+	template<typename genType> 
 	GLM_FUNC_DECL genType factorial(genType const & x);
 
 	//! 32bit signed integer. 
diff --git a/glm/gtx/integer.inl b/glm/gtx/integer.inl
index 3a479e6c..bddfd2ca 100644
--- a/glm/gtx/integer.inl
+++ b/glm/gtx/integer.inl
@@ -69,7 +69,7 @@ namespace detail
 	}
 
 	// factorial (!12 max, integer only)
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER genType factorial(genType const & x)
 	{
 		genType Temp = x;
@@ -79,30 +79,30 @@ namespace detail
 		return Result;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P> factorial(
-		tvec2<T, P> const & x)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<2, T, P> factorial(
+		vec<2, T, P> const & x)
 	{
-		return tvec2<T, P>(
+		return vec<2, T, P>(
 			factorial(x.x),
 			factorial(x.y));
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> factorial(
-		tvec3<T, P> const & x)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> factorial(
+		vec<3, T, P> const & x)
 	{
-		return tvec3<T, P>(
+		return vec<3, T, P>(
 			factorial(x.x),
 			factorial(x.y),
 			factorial(x.z));
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> factorial(
-		tvec4<T, P> const & x)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, T, P> factorial(
+		vec<4, T, P> const & x)
 	{
-		return tvec4<T, P>(
+		return vec<4, T, P>(
 			factorial(x.x),
 			factorial(x.y),
 			factorial(x.z),
diff --git a/glm/gtx/intersect.hpp b/glm/gtx/intersect.hpp
index 129d2365..a6a78633 100644
--- a/glm/gtx/intersect.hpp
+++ b/glm/gtx/intersect.hpp
@@ -37,7 +37,7 @@ namespace glm
 	//! Compute the intersection of a ray and a plane.
 	//! Ray direction and plane normal must be unit length.
 	//! From GLM_GTX_intersect extension.
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL bool intersectRayPlane(
 		genType const & orig, genType const & dir,
 		genType const & planeOrig, genType const & planeNormal,
@@ -46,15 +46,15 @@ namespace glm
 	//! Compute the intersection of a ray and a triangle.
 	/// Based om Tomas Möller implementation http://fileadmin.cs.lth.se/cs/Personal/Tomas_Akenine-Moller/raytri/
 	//! From GLM_GTX_intersect extension.
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_DECL bool intersectRayTriangle(
-		tvec3<T, P> const& orig, tvec3<T, P> const& dir,
-		tvec3<T, P> const& v0, tvec3<T, P> const& v1, tvec3<T, P> const& v2,
-		tvec3<T, P>& baryPosition, T& distance);
+		vec<3, T, P> const& orig, vec<3, T, P> const& dir,
+		vec<3, T, P> const& v0, vec<3, T, P> const& v1, vec<3, T, P> const& v2,
+		vec<3, T, P>& baryPosition, T& distance);
 
 	//! Compute the intersection of a line and a triangle.
 	//! From GLM_GTX_intersect extension.
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL bool intersectLineTriangle(
 		genType const & orig, genType const & dir,
 		genType const & vert0, genType const & vert1, genType const & vert2,
@@ -63,7 +63,7 @@ namespace glm
 	//! Compute the intersection distance of a ray and a sphere. 
 	//! The ray direction vector is unit length.
 	//! From GLM_GTX_intersect extension.
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL bool intersectRaySphere(
 		genType const & rayStarting, genType const & rayNormalizedDirection,
 		genType const & sphereCenter, typename genType::value_type const sphereRadiusSquered,
@@ -71,7 +71,7 @@ namespace glm
 
 	//! Compute the intersection of a ray and a sphere.
 	//! From GLM_GTX_intersect extension.
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL bool intersectRaySphere(
 		genType const & rayStarting, genType const & rayNormalizedDirection,
 		genType const & sphereCenter, const typename genType::value_type sphereRadius,
@@ -79,7 +79,7 @@ namespace glm
 
 	//! Compute the intersection of a line and a sphere.
 	//! From GLM_GTX_intersect extension
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL bool intersectLineSphere(
 		genType const & point0, genType const & point1,
 		genType const & sphereCenter, typename genType::value_type sphereRadius,
diff --git a/glm/gtx/intersect.inl b/glm/gtx/intersect.inl
index fb9a29b1..b97b073e 100644
--- a/glm/gtx/intersect.inl
+++ b/glm/gtx/intersect.inl
@@ -3,7 +3,7 @@
 
 namespace glm
 {
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER bool intersectRayPlane
 	(
 		genType const & orig, genType const & dir,
@@ -23,30 +23,30 @@ namespace glm
 		return false;
 	}
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER bool intersectRayTriangle
 	(
-		tvec3<T, P> const& orig, tvec3<T, P> const& dir,
-		tvec3<T, P> const& vert0, tvec3<T, P> const& vert1, tvec3<T, P> const& vert2,
-		tvec2<T, P>& baryPosition, T& distance
+		vec<3, T, P> const& orig, vec<3, T, P> const& dir,
+		vec<3, T, P> const& vert0, vec<3, T, P> const& vert1, vec<3, T, P> const& vert2,
+		vec<2, T, P>& baryPosition, T& distance
 	)
 	{
 		// find vectors for two edges sharing vert0
-		tvec3<T, P> const edge1 = vert1 - vert0;
-		tvec3<T, P> const edge2 = vert2 - vert0;
+		vec<3, T, P> const edge1 = vert1 - vert0;
+		vec<3, T, P> const edge2 = vert2 - vert0;
 
 		// begin calculating determinant - also used to calculate U parameter
-		tvec3<T, P> const p = glm::cross(dir, edge2);
+		vec<3, T, P> const p = glm::cross(dir, edge2);
 
 		// if determinant is near zero, ray lies in plane of triangle
 		T const det = glm::dot(edge1, p);
 
-		tvec3<T, P> qvec;
+		vec<3, T, P> qvec;
 
 		if(det > std::numeric_limits<T>::epsilon())
 		{
 			// calculate distance from vert0 to ray origin
-			tvec3<T, P> const tvec = orig - vert0;
+			vec<3, T, P> const tvec = orig - vert0;
 
 			// calculate U parameter and test bounds
 			baryPosition.x = glm::dot(tvec, p);
@@ -64,7 +64,7 @@ namespace glm
 		else if(det < -std::numeric_limits<T>::epsilon())
 		{
 			// calculate distance from vert0 to ray origin
-			tvec3<T, P> const tvec = orig - vert0;
+			vec<3, T, P> const tvec = orig - vert0;
 
 			// calculate U parameter and test bounds
 			baryPosition.x = glm::dot(tvec, p);
@@ -118,7 +118,7 @@ namespace glm
 	}
 */
 
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER bool intersectLineTriangle
 	(
 		genType const & orig, genType const & dir,
@@ -156,7 +156,7 @@ namespace glm
 		return true;
 	}
 
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER bool intersectRaySphere
 	(
 		genType const & rayStarting, genType const & rayNormalizedDirection,
@@ -177,7 +177,7 @@ namespace glm
 		return intersectionDistance > Epsilon;
 	}
 
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER bool intersectRaySphere
 	(
 		genType const & rayStarting, genType const & rayNormalizedDirection,
@@ -195,7 +195,7 @@ namespace glm
 		return false;
 	}
 
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER bool intersectLineSphere
 	(
 		genType const & point0, genType const & point1,
diff --git a/glm/gtx/io.hpp b/glm/gtx/io.hpp
index 93281ffc..c1a2d274 100644
--- a/glm/gtx/io.hpp
+++ b/glm/gtx/io.hpp
@@ -44,7 +44,7 @@ namespace glm
 	{
 		enum order_type { column_major, row_major};
 
-		template <typename CTy>
+		template<typename CTy>
 		class format_punct : public std::locale::facet
 		{
 			typedef CTy char_type;
@@ -67,7 +67,7 @@ namespace glm
 			GLM_FUNC_DECL explicit format_punct(format_punct const&);
 		};
 
-		template <typename CTy, typename CTr = std::char_traits<CTy> >
+		template<typename CTy, typename CTr = std::char_traits<CTy> >
 		class basic_state_saver {
 
 		public:
@@ -96,7 +96,7 @@ namespace glm
 		typedef basic_state_saver<char>     state_saver;
 		typedef basic_state_saver<wchar_t> wstate_saver;
 
-		template <typename CTy, typename CTr = std::char_traits<CTy> >
+		template<typename CTy, typename CTr = std::char_traits<CTy> >
 		class basic_format_saver
 		{
 		public:
@@ -128,7 +128,7 @@ namespace glm
 			GLM_FUNC_DECL explicit width(unsigned);
 		};
 
-		template <typename CTy>
+		template<typename CTy>
 		struct delimeter
 		{
 			CTy value[3];
@@ -145,55 +145,55 @@ namespace glm
 
 		// functions, inlined (inline)
 
-		template <typename FTy, typename CTy, typename CTr>
+		template<typename FTy, typename CTy, typename CTr>
 		FTy const& get_facet(std::basic_ios<CTy,CTr>&);
-		template <typename FTy, typename CTy, typename CTr>
+		template<typename FTy, typename CTy, typename CTr>
 		std::basic_ios<CTy,CTr>& formatted(std::basic_ios<CTy,CTr>&);
-		template <typename FTy, typename CTy, typename CTr>
+		template<typename FTy, typename CTy, typename CTr>
 		std::basic_ios<CTy,CTr>& unformattet(std::basic_ios<CTy,CTr>&);
 
-		template <typename CTy, typename CTr>
+		template<typename CTy, typename CTr>
 		std::basic_ostream<CTy, CTr>& operator<<(std::basic_ostream<CTy, CTr>&, precision const&);
-		template <typename CTy, typename CTr>
+		template<typename CTy, typename CTr>
 		std::basic_ostream<CTy, CTr>& operator<<(std::basic_ostream<CTy, CTr>&, width const&);
-		template <typename CTy, typename CTr>
+		template<typename CTy, typename CTr>
 		std::basic_ostream<CTy, CTr>& operator<<(std::basic_ostream<CTy, CTr>&, delimeter<CTy> const&);
-		template <typename CTy, typename CTr>
+		template<typename CTy, typename CTr>
 		std::basic_ostream<CTy, CTr>& operator<<(std::basic_ostream<CTy, CTr>&, order const&);
 	}//namespace io
 
-	template <typename CTy, typename CTr, typename T, precision P>
+	template<typename CTy, typename CTr, typename T, precision P>
 	GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tquat<T,P> const&);
-	template <typename CTy, typename CTr, typename T, precision P>
-	GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tvec1<T,P> const&);
-	template <typename CTy, typename CTr, typename T, precision P>
-	GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tvec2<T,P> const&);
-	template <typename CTy, typename CTr, typename T, precision P>
-	GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tvec3<T,P> const&);
-	template <typename CTy, typename CTr, typename T, precision P>
-	GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tvec4<T,P> const&);
-	template <typename CTy, typename CTr, typename T, precision P>
-	GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat2x2<T,P> const&);
-	template <typename CTy, typename CTr, typename T, precision P>
-	GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat2x3<T,P> const&);
-	template <typename CTy, typename CTr, typename T, precision P>
-	GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat2x4<T,P> const&);
-	template <typename CTy, typename CTr, typename T, precision P>
-	GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat3x2<T,P> const&);
-	template <typename CTy, typename CTr, typename T, precision P>
-	GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat3x3<T,P> const&);
-	template <typename CTy, typename CTr, typename T, precision P>
-	GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat3x4<T,P> const&);
-	template <typename CTy, typename CTr, typename T, precision P>
-	GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat4x2<T,P> const&);
-	template <typename CTy, typename CTr, typename T, precision P>
-	GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat4x3<T,P> const&);
-	template <typename CTy, typename CTr, typename T, precision P>
-	GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat4x4<T,P> const&);
+	template<typename CTy, typename CTr, typename T, precision P>
+	GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, vec<1, T,P> const&);
+	template<typename CTy, typename CTr, typename T, precision P>
+	GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, vec<2, T,P> const&);
+	template<typename CTy, typename CTr, typename T, precision P>
+	GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, vec<3, T,P> const&);
+	template<typename CTy, typename CTr, typename T, precision P>
+	GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, vec<4, T,P> const&);
+	template<typename CTy, typename CTr, typename T, precision P>
+	GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, mat<2, 2, T,P> const&);
+	template<typename CTy, typename CTr, typename T, precision P>
+	GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, mat<2, 3, T,P> const&);
+	template<typename CTy, typename CTr, typename T, precision P>
+	GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, mat<2, 4, T,P> const&);
+	template<typename CTy, typename CTr, typename T, precision P>
+	GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, mat<3, 2, T,P> const&);
+	template<typename CTy, typename CTr, typename T, precision P>
+	GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, mat<3, 3, T,P> const&);
+	template<typename CTy, typename CTr, typename T, precision P>
+	GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, mat<3, 4, T,P> const&);
+	template<typename CTy, typename CTr, typename T, precision P>
+	GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, mat<4, 2, T,P> const&);
+	template<typename CTy, typename CTr, typename T, precision P>
+	GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, mat<4, 3, T,P> const&);
+	template<typename CTy, typename CTr, typename T, precision P>
+	GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, mat<4, 4, T,P> const&);
 
-  template <typename CTy, typename CTr, typename T, precision P>
+  template<typename CTy, typename CTr, typename T, precision P>
 	GLM_FUNC_DECL std::basic_ostream<CTy,CTr> & operator<<(std::basic_ostream<CTy,CTr> &,
-                                                         std::pair<tmat4x4<T,P> const, tmat4x4<T,P> const> const &);
+                                                         std::pair<mat<4, 4, T,P> const, mat<4, 4, T,P> const> const &);
 
 	/// @}
 }//namespace glm
diff --git a/glm/gtx/io.inl b/glm/gtx/io.inl
index 9b70a5fd..e4f72570 100644
--- a/glm/gtx/io.inl
+++ b/glm/gtx/io.inl
@@ -10,7 +10,7 @@
 namespace glm{
 namespace io
 {
-	template <typename CTy>
+	template<typename CTy>
 	GLM_FUNC_QUALIFIER format_punct<CTy>::format_punct(size_t a)
 		: std::locale::facet(a)
 		, formatted(true)
@@ -24,7 +24,7 @@ namespace io
 		, order(column_major)
 	{}
 
-	template <typename CTy>
+	template<typename CTy>
 	GLM_FUNC_QUALIFIER format_punct<CTy>::format_punct(format_punct const& a)
 		: std::locale::facet(0)
 		, formatted(a.formatted)
@@ -38,9 +38,9 @@ namespace io
 		, order(a.order)
 	{}
 
-	template <typename CTy> std::locale::id format_punct<CTy>::id;
+	template<typename CTy> std::locale::id format_punct<CTy>::id;
 
-	template <typename CTy, typename CTr>
+	template<typename CTy, typename CTr>
 	GLM_FUNC_QUALIFIER basic_state_saver<CTy, CTr>::basic_state_saver(std::basic_ios<CTy, CTr>& a)
 		: state_(a)
 		, flags_(a.flags())
@@ -50,7 +50,7 @@ namespace io
 		, locale_(a.getloc())
 	{}
 
-	template <typename CTy, typename CTr>
+	template<typename CTy, typename CTr>
 	GLM_FUNC_QUALIFIER basic_state_saver<CTy, CTr>::~basic_state_saver()
 	{
 		state_.imbue(locale_);
@@ -60,14 +60,14 @@ namespace io
 		state_.flags(flags_);
 	}
 
-	template <typename CTy, typename CTr>
+	template<typename CTy, typename CTr>
 	GLM_FUNC_QUALIFIER basic_format_saver<CTy, CTr>::basic_format_saver(std::basic_ios<CTy, CTr>& a)
 		: bss_(a)
 	{
 		a.imbue(std::locale(a.getloc(), new format_punct<CTy>(get_facet<format_punct<CTy> >(a))));
 	}
 
-	template <typename CTy, typename CTr>
+	template<typename CTy, typename CTr>
 	GLM_FUNC_QUALIFIER
 	basic_format_saver<CTy, CTr>::~basic_format_saver()
 	{}
@@ -80,7 +80,7 @@ namespace io
 		: value(a)
 	{}
 
-	template <typename CTy>
+	template<typename CTy>
 	GLM_FUNC_QUALIFIER delimeter<CTy>::delimeter(CTy a, CTy b, CTy c)
 		: value()
 	{
@@ -93,7 +93,7 @@ namespace io
 		: value(a)
 	{}
 
-	template <typename FTy, typename CTy, typename CTr>
+	template<typename FTy, typename CTy, typename CTr>
 	GLM_FUNC_QUALIFIER FTy const& get_facet(std::basic_ios<CTy, CTr>& ios)
 	{
 		if(!std::has_facet<FTy>(ios.getloc()))
@@ -102,35 +102,35 @@ namespace io
 		return std::use_facet<FTy>(ios.getloc());
 	}
 
-	template <typename CTy, typename CTr>
+	template<typename CTy, typename CTr>
 	GLM_FUNC_QUALIFIER std::basic_ios<CTy, CTr>& formatted(std::basic_ios<CTy, CTr>& ios)
 	{
 		const_cast<format_punct<CTy>&>(get_facet<format_punct<CTy> >(ios)).formatted = true;
 		return ios;
 	}
 
-	template <typename CTy, typename CTr>
+	template<typename CTy, typename CTr>
 	GLM_FUNC_QUALIFIER std::basic_ios<CTy, CTr>& unformatted(std::basic_ios<CTy, CTr>& ios)
 	{
 		const_cast<format_punct<CTy>&>(get_facet<format_punct<CTy> >(ios)).formatted = false;
 		return ios;
 	}
 
-	template <typename CTy, typename CTr>
+	template<typename CTy, typename CTr>
 	GLM_FUNC_QUALIFIER std::basic_ostream<CTy, CTr>& operator<<(std::basic_ostream<CTy, CTr>& os, precision const& a)
 	{
 		const_cast<format_punct<CTy>&>(get_facet<format_punct<CTy> >(os)).precision = a.value;
 		return os;
 	}
 
-	template <typename CTy, typename CTr>
+	template<typename CTy, typename CTr>
 	GLM_FUNC_QUALIFIER std::basic_ostream<CTy, CTr>& operator<<(std::basic_ostream<CTy, CTr>& os, width const& a)
 	{
 		const_cast<format_punct<CTy>&>(get_facet<format_punct<CTy> >(os)).width = a.value;
 		return os;
 	}
 
-	template <typename CTy, typename CTr>
+	template<typename CTy, typename CTr>
 	GLM_FUNC_QUALIFIER  std::basic_ostream<CTy, CTr>& operator<<(std::basic_ostream<CTy, CTr>& os, delimeter<CTy> const& a)
 	{
 		format_punct<CTy> & fmt(const_cast<format_punct<CTy>&>(get_facet<format_punct<CTy> >(os)));
@@ -142,7 +142,7 @@ namespace io
 		return os;
 	}
 
-	template <typename CTy, typename CTr>
+	template<typename CTy, typename CTr>
 	GLM_FUNC_QUALIFIER std::basic_ostream<CTy, CTr>& operator<<(std::basic_ostream<CTy, CTr>& os, order const& a)
 	{
 		const_cast<format_punct<CTy>&>(get_facet<format_punct<CTy> >(os)).order = a.value;
@@ -152,9 +152,9 @@ namespace io
 
 namespace detail
 {
-	template <typename CTy, typename CTr, template <typename, precision> class V, typename T, precision P>
+	template<typename CTy, typename CTr, typename V>
 	GLM_FUNC_QUALIFIER std::basic_ostream<CTy, CTr>&
-	print_vector_on(std::basic_ostream<CTy, CTr>& os, V<T,P> const& a)
+	print_vector_on(std::basic_ostream<CTy, CTr>& os, V const& a)
 	{
 		typename std::basic_ostream<CTy, CTr>::sentry const cerberus(os);
 
@@ -162,7 +162,7 @@ namespace detail
 		{
 			io::format_punct<CTy> const & fmt(io::get_facet<io::format_punct<CTy> >(os));
 
-			length_t const& components(type<V, T, P>::components);
+			length_t const& components(type<V>::components);
 
 			if(fmt.formatted)
 			{
@@ -195,40 +195,40 @@ namespace detail
 	}
 }//namespace detail
 
-	template <typename CTy, typename CTr, typename T, precision P>
+	template<typename CTy, typename CTr, typename T, precision P>
 	GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>& os, tquat<T,P> const& a)
 	{
 		return detail::print_vector_on(os, a);
 	}
 
-	template <typename CTy, typename CTr, typename T, precision P>
-	GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>& os, tvec1<T,P> const& a)
+	template<typename CTy, typename CTr, typename T, precision P>
+	GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>& os, vec<1, T,P> const& a)
 	{
 		return detail::print_vector_on(os, a);
 	}
 
-	template <typename CTy, typename CTr, typename T, precision P>
-	GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>& os, tvec2<T,P> const& a)
+	template<typename CTy, typename CTr, typename T, precision P>
+	GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>& os, vec<2, T,P> const& a)
 	{
 		return detail::print_vector_on(os, a);
 	}
 
-	template <typename CTy, typename CTr, typename T, precision P>
-	GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>& os, tvec3<T,P> const& a)
+	template<typename CTy, typename CTr, typename T, precision P>
+	GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>& os, vec<3, T,P> const& a)
 	{
 		return detail::print_vector_on(os, a);
 	}
 
-	template <typename CTy, typename CTr, typename T, precision P>
-	GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>& os, tvec4<T,P> const& a)
+	template<typename CTy, typename CTr, typename T, precision P>
+	GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>& os, vec<4, T,P> const& a)
 	{
 		return detail::print_vector_on(os, a);
 	}
 
 namespace detail
 {
-	template <typename CTy, typename CTr, template <typename, precision> class M, typename T, precision P>
-	GLM_FUNC_QUALIFIER std::basic_ostream<CTy, CTr>& print_matrix_on(std::basic_ostream<CTy, CTr>& os, M<T,P> const& a)
+	template<typename CTy, typename CTr, template<length_t, length_t, typename, precision> class M, length_t C, length_t R, typename T, precision P>
+	GLM_FUNC_QUALIFIER std::basic_ostream<CTy, CTr>& print_matrix_on(std::basic_ostream<CTy, CTr>& os, M<C, R, T, P> const& a)
 	{
 		typename std::basic_ostream<CTy,CTr>::sentry const cerberus(os);
 
@@ -236,8 +236,8 @@ namespace detail
 		{
 			io::format_punct<CTy> const & fmt(io::get_facet<io::format_punct<CTy> >(os));
 
-			length_t const& cols(type<M, T, P>::cols);
-			length_t const& rows(type<M, T, P>::rows);
+			length_t const& cols(type<M<C, R, T, P> >::cols);
+			length_t const& rows(type<M<C, R, T, P> >::rows);
 
 			if(fmt.formatted)
 			{
@@ -313,74 +313,74 @@ namespace detail
 	}
 }//namespace detail
 
-	template <typename CTy, typename CTr, typename T, precision P>
-	GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>& os, tmat2x2<T,P> const& a)
+	template<typename CTy, typename CTr, typename T, precision P>
+	GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>& os, mat<2, 2, T, P> const& a)
 	{
 		return detail::print_matrix_on(os, a);
 	}
 
-	template <typename CTy, typename CTr, typename T, precision P>
-	GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>& os, tmat2x3<T,P> const& a)
+	template<typename CTy, typename CTr, typename T, precision P>
+	GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>& os, mat<2, 3, T, P> const& a)
 	{
 		return detail::print_matrix_on(os, a);
 	}
 
-	template <typename CTy, typename CTr, typename T, precision P>
-	GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>& os, tmat2x4<T,P> const& a)
+	template<typename CTy, typename CTr, typename T, precision P>
+	GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>& os, mat<2, 4, T, P> const& a)
 	{
 		return detail::print_matrix_on(os, a);
 	}
 
-	template <typename CTy, typename CTr, typename T, precision P>
-	GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>& os, tmat3x2<T,P> const& a)
+	template<typename CTy, typename CTr, typename T, precision P>
+	GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>& os, mat<3, 2, T,P> const& a)
 	{
 		return detail::print_matrix_on(os, a);
 	}
 
-	template <typename CTy, typename CTr, typename T, precision P>
-	GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>& os, tmat3x3<T,P> const& a)
+	template<typename CTy, typename CTr, typename T, precision P>
+	GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>& os, mat<3, 3, T,P> const& a)
 	{
 		return detail::print_matrix_on(os, a);
 	}
 
-	template <typename CTy, typename CTr, typename T, precision P>
-	GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr> & operator<<(std::basic_ostream<CTy,CTr>& os, tmat3x4<T,P> const& a)
+	template<typename CTy, typename CTr, typename T, precision P>
+	GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr> & operator<<(std::basic_ostream<CTy,CTr>& os, mat<3, 4, T,P> const& a)
 	{
 		return detail::print_matrix_on(os, a);
 	}
 
-	template <typename CTy, typename CTr, typename T, precision P>
-	GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr> & operator<<(std::basic_ostream<CTy,CTr>& os, tmat4x2<T,P> const& a)
+	template<typename CTy, typename CTr, typename T, precision P>
+	GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr> & operator<<(std::basic_ostream<CTy,CTr>& os, mat<4, 2, T,P> const& a)
 	{
 		return detail::print_matrix_on(os, a);
 	}
 
-	template <typename CTy, typename CTr, typename T, precision P>
-	GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr> & operator<<(std::basic_ostream<CTy,CTr>& os, tmat4x3<T,P> const& a)
+	template<typename CTy, typename CTr, typename T, precision P>
+	GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr> & operator<<(std::basic_ostream<CTy,CTr>& os, mat<4, 3, T,P> const& a)
 	{
 		return detail::print_matrix_on(os, a);
 	}
 
-	template <typename CTy, typename CTr, typename T, precision P>
-	GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr> & operator<<(std::basic_ostream<CTy,CTr>& os, tmat4x4<T,P> const& a)
+	template<typename CTy, typename CTr, typename T, precision P>
+	GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr> & operator<<(std::basic_ostream<CTy,CTr>& os, mat<4, 4, T,P> const& a)
 	{
 		return detail::print_matrix_on(os, a);
 	}
 
 namespace detail
 {
-	template <typename CTy, typename CTr, template <typename, precision> class M, typename T, precision P>
-	GLM_FUNC_QUALIFIER std::basic_ostream<CTy, CTr>& print_matrix_pair_on(std::basic_ostream<CTy, CTr>& os, std::pair<M<T, P> const, M<T, P> const> const& a)
+	template<typename CTy, typename CTr, template<length_t, length_t, typename, precision> class M, length_t C, length_t R, typename T, precision P>
+	GLM_FUNC_QUALIFIER std::basic_ostream<CTy, CTr>& print_matrix_pair_on(std::basic_ostream<CTy, CTr>& os, std::pair<M<C, R, T, P> const, M<C, R, T, P> const> const& a)
 	{
 		typename std::basic_ostream<CTy,CTr>::sentry const cerberus(os);
 
 		if(cerberus)
 		{
 			io::format_punct<CTy> const& fmt(io::get_facet<io::format_punct<CTy> >(os));
-			M<T,P> const& ml(a.first);
-			M<T,P> const& mr(a.second);
-			length_t const& cols(type<M, T, P>::cols);
-			length_t const& rows(type<M, T, P>::rows);
+			M<C, R, T,P> const& ml(a.first);
+			M<C, R, T,P> const& mr(a.second);
+			length_t const& cols(type<M<C, R, T, P> >::cols);
+			length_t const& rows(type<M<C, R, T, P> >::rows);
 
 			if(fmt.formatted)
 			{
@@ -430,11 +430,11 @@ namespace detail
 	}
 }//namespace detail
 
-	template <typename CTy, typename CTr, typename T, precision P>
+	template<typename CTy, typename CTr, typename T, precision P>
 	GLM_FUNC_QUALIFIER std::basic_ostream<CTy, CTr>& operator<<(
 		std::basic_ostream<CTy, CTr> & os,
-		std::pair<tmat4x4<T, P> const,
-		tmat4x4<T, P> const> const& a)
+		std::pair<mat<4, 4, T, P> const,
+		mat<4, 4, T, P> const> const& a)
 	{
 		return detail::print_matrix_pair_on(os, a);
 	}
diff --git a/glm/gtx/log_base.hpp b/glm/gtx/log_base.hpp
index 75f12169..577c7914 100644
--- a/glm/gtx/log_base.hpp
+++ b/glm/gtx/log_base.hpp
@@ -30,17 +30,17 @@ namespace glm
 
 	/// Logarithm for any base.
 	/// From GLM_GTX_log_base.
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL genType log(
 		genType const & x,
 		genType const & base);
 
 	/// Logarithm for any base.
 	/// From GLM_GTX_log_base.
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> sign(
-		vecType<T, P> const & x,
-		vecType<T, P> const & base);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, T, P> sign(
+		vecType<L, T, P> const& x,
+		vecType<L, T, P> const& base);
 
 	/// @}
 }//namespace glm
diff --git a/glm/gtx/log_base.inl b/glm/gtx/log_base.inl
index 8005d1ba..9155778a 100644
--- a/glm/gtx/log_base.inl
+++ b/glm/gtx/log_base.inl
@@ -3,15 +3,15 @@
 
 namespace glm
 {
-	template <typename genType> 
+	template<typename genType> 
 	GLM_FUNC_QUALIFIER genType log(genType const & x, genType const & base)
 	{
 		assert(x != genType(0));
 		return glm::log(x) / glm::log(base);
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> log(vecType<T, P> const & x, vecType<T, P> const & base)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> log(vecType<L, T, P> const & x, vecType<L, T, P> const & base)
 	{
 		return glm::log(x) / glm::log(base);
 	}
diff --git a/glm/gtx/matrix_cross_product.hpp b/glm/gtx/matrix_cross_product.hpp
index 7d8559ce..0b1bb48e 100644
--- a/glm/gtx/matrix_cross_product.hpp
+++ b/glm/gtx/matrix_cross_product.hpp
@@ -31,15 +31,15 @@ namespace glm
 
 	//! Build a cross product matrix.
 	//! From GLM_GTX_matrix_cross_product extension.
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat3x3<T, P> matrixCross3(
-		tvec3<T, P> const & x);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<3, 3, T, P> matrixCross3(
+		vec<3, T, P> const & x);
 		
 	//! Build a cross product matrix.
 	//! From GLM_GTX_matrix_cross_product extension.
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat4x4<T, P> matrixCross4(
-		tvec3<T, P> const & x);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<4, 4, T, P> matrixCross4(
+		vec<3, T, P> const & x);
 
 	/// @}
 }//namespace glm
diff --git a/glm/gtx/matrix_cross_product.inl b/glm/gtx/matrix_cross_product.inl
index 16f07e96..e1b2fe90 100644
--- a/glm/gtx/matrix_cross_product.inl
+++ b/glm/gtx/matrix_cross_product.inl
@@ -3,13 +3,13 @@
 
 namespace glm
 {
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x3<T, P> matrixCross3
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, P> matrixCross3
 	(
-		tvec3<T, P> const & x
+		vec<3, T, P> const & x
 	)
 	{
-		tmat3x3<T, P> Result(T(0));
+		mat<3, 3, T, P> Result(T(0));
 		Result[0][1] = x.z;
 		Result[1][0] = -x.z;
 		Result[0][2] = -x.y;
@@ -19,13 +19,13 @@ namespace glm
 		return Result;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> matrixCross4
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, P> matrixCross4
 	(
-		tvec3<T, P> const & x
+		vec<3, T, P> const & x
 	)
 	{
-		tmat4x4<T, P> Result(T(0));
+		mat<4, 4, T, P> Result(T(0));
 		Result[0][1] = x.z;
 		Result[1][0] = -x.z;
 		Result[0][2] = -x.y;
diff --git a/glm/gtx/matrix_decompose.hpp b/glm/gtx/matrix_decompose.hpp
index 7fc56a30..5a9225ce 100644
--- a/glm/gtx/matrix_decompose.hpp
+++ b/glm/gtx/matrix_decompose.hpp
@@ -35,10 +35,10 @@ namespace glm
 
 	/// Decomposes a model matrix to translations, rotation and scale components 
 	/// @see gtx_matrix_decompose
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_DECL bool decompose(
-		tmat4x4<T, P> const & modelMatrix,
-		tvec3<T, P> & scale, tquat<T, P> & orientation, tvec3<T, P> & translation, tvec3<T, P> & skew, tvec4<T, P> & perspective);
+		mat<4, 4, T, P> const& modelMatrix,
+		vec<3, T, P> & scale, tquat<T, P> & orientation, vec<3, T, P> & translation, vec<3, T, P> & skew, vec<4, T, P> & perspective);
 
 	/// @}
 }//namespace glm
diff --git a/glm/gtx/matrix_decompose.inl b/glm/gtx/matrix_decompose.inl
index 913f8f4d..3cd58811 100644
--- a/glm/gtx/matrix_decompose.inl
+++ b/glm/gtx/matrix_decompose.inl
@@ -6,17 +6,17 @@ namespace detail
 {
 	/// Make a linear combination of two vectors and return the result.
 	// result = (a * ascl) + (b * bscl)
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> combine(
-		tvec3<T, P> const & a, 
-		tvec3<T, P> const & b,
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> combine(
+		vec<3, T, P> const & a, 
+		vec<3, T, P> const & b,
 		T ascl, T bscl)
 	{
 		return (a * ascl) + (b * bscl);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> scale(tvec3<T, P> const& v, T desiredLength)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> scale(vec<3, T, P> const& v, T desiredLength)
 	{
 		return v * desiredLength / length(v);
 	}
@@ -26,10 +26,10 @@ namespace detail
 	// http://www.opensource.apple.com/source/WebCore/WebCore-514/platform/graphics/transforms/TransformationMatrix.cpp
 	// Decomposes the mode matrix to translations,rotation scale components
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER bool decompose(tmat4x4<T, P> const & ModelMatrix, tvec3<T, P> & Scale, tquat<T, P> & Orientation, tvec3<T, P> & Translation, tvec3<T, P> & Skew, tvec4<T, P> & Perspective)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER bool decompose(mat<4, 4, T, P> const & ModelMatrix, vec<3, T, P> & Scale, tquat<T, P> & Orientation, vec<3, T, P> & Translation, vec<3, T, P> & Skew, vec<4, T, P> & Perspective)
 	{
-		tmat4x4<T, P> LocalMatrix(ModelMatrix);
+		mat<4, 4, T, P> LocalMatrix(ModelMatrix);
 
 		// Normalize the matrix.
 		if(LocalMatrix[3][3] == static_cast<T>(0))
@@ -41,7 +41,7 @@ namespace detail
 
 		// perspectiveMatrix is used to solve for perspective, but it also provides
 		// an easy way to test for singularity of the upper 3x3 component.
-		tmat4x4<T, P> PerspectiveMatrix(LocalMatrix);
+		mat<4, 4, T, P> PerspectiveMatrix(LocalMatrix);
 
 		for(length_t i = 0; i < 3; i++)
 			PerspectiveMatrix[i][3] = static_cast<T>(0);
@@ -55,7 +55,7 @@ namespace detail
 		if(LocalMatrix[0][3] != static_cast<T>(0) || LocalMatrix[1][3] != static_cast<T>(0) || LocalMatrix[2][3] != static_cast<T>(0))
 		{
 			// rightHandSide is the right hand side of the equation.
-			tvec4<T, P> RightHandSide;
+			vec<4, T, P> RightHandSide;
 			RightHandSide[0] = LocalMatrix[0][3];
 			RightHandSide[1] = LocalMatrix[1][3];
 			RightHandSide[2] = LocalMatrix[2][3];
@@ -64,8 +64,8 @@ namespace detail
 			// Solve the equation by inverting PerspectiveMatrix and multiplying
 			// rightHandSide by the inverse.  (This is the easiest way, not
 			// necessarily the best.)
-			tmat4x4<T, P> InversePerspectiveMatrix = glm::inverse(PerspectiveMatrix);//   inverse(PerspectiveMatrix, inversePerspectiveMatrix);
-			tmat4x4<T, P> TransposedInversePerspectiveMatrix = glm::transpose(InversePerspectiveMatrix);//   transposeMatrix4(inversePerspectiveMatrix, transposedInversePerspectiveMatrix);
+			mat<4, 4, T, P> InversePerspectiveMatrix = glm::inverse(PerspectiveMatrix);//   inverse(PerspectiveMatrix, inversePerspectiveMatrix);
+			mat<4, 4, T, P> TransposedInversePerspectiveMatrix = glm::transpose(InversePerspectiveMatrix);//   transposeMatrix4(inversePerspectiveMatrix, transposedInversePerspectiveMatrix);
 
 			Perspective = TransposedInversePerspectiveMatrix * RightHandSide;
 			//  v4MulPointByMatrix(rightHandSide, transposedInversePerspectiveMatrix, perspectivePoint);
@@ -77,14 +77,14 @@ namespace detail
 		else
 		{
 			// No perspective.
-			Perspective = tvec4<T, P>(0, 0, 0, 1);
+			Perspective = vec<4, T, P>(0, 0, 0, 1);
 		}
 
 		// Next take care of translation (easy).
-		Translation = tvec3<T, P>(LocalMatrix[3]);
-		LocalMatrix[3] = tvec4<T, P>(0, 0, 0, LocalMatrix[3].w);
+		Translation = vec<3, T, P>(LocalMatrix[3]);
+		LocalMatrix[3] = vec<4, T, P>(0, 0, 0, LocalMatrix[3].w);
 
-		tvec3<T, P> Row[3], Pdum3;
+		vec<3, T, P> Row[3], Pdum3;
 
 		// Now get scale and shear.
 		for(length_t i = 0; i < 3; ++i)
diff --git a/glm/gtx/matrix_interpolation.hpp b/glm/gtx/matrix_interpolation.hpp
index ec44f00e..4e7f49dd 100644
--- a/glm/gtx/matrix_interpolation.hpp
+++ b/glm/gtx/matrix_interpolation.hpp
@@ -31,32 +31,32 @@ namespace glm
 
 	/// Get the axis and angle of the rotation from a matrix.
 	/// From GLM_GTX_matrix_interpolation extension.
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_DECL void axisAngle(
-		tmat4x4<T, P> const & mat,
-		tvec3<T, P> & axis,
+		mat<4, 4, T, P> const& mat,
+		vec<3, T, P> & axis,
 		T & angle);
 
 	/// Build a matrix from axis and angle.
 	/// From GLM_GTX_matrix_interpolation extension.
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat4x4<T, P> axisAngleMatrix(
-		tvec3<T, P> const & axis,
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<4, 4, T, P> axisAngleMatrix(
+		vec<3, T, P> const & axis,
 		T const angle);
 
 	/// Extracts the rotation part of a matrix.
 	/// From GLM_GTX_matrix_interpolation extension.
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat4x4<T, P> extractMatrixRotation(
-		tmat4x4<T, P> const & mat);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<4, 4, T, P> extractMatrixRotation(
+		mat<4, 4, T, P> const& mat);
 
 	/// Build a interpolation of 4 * 4 matrixes.
 	/// From GLM_GTX_matrix_interpolation extension.
 	/// Warning! works only with rotation and/or translation matrixes, scale will generate unexpected results.
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat4x4<T, P> interpolate(
-		tmat4x4<T, P> const & m1,
-		tmat4x4<T, P> const & m2,
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<4, 4, T, P> interpolate(
+		mat<4, 4, T, P> const& m1,
+		mat<4, 4, T, P> const& m2,
 		T const delta);
 
 	/// @}
diff --git a/glm/gtx/matrix_interpolation.inl b/glm/gtx/matrix_interpolation.inl
index 12c1a5b5..8e99ac4d 100644
--- a/glm/gtx/matrix_interpolation.inl
+++ b/glm/gtx/matrix_interpolation.inl
@@ -3,11 +3,11 @@
 
 namespace glm
 {
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER void axisAngle
 	(
-		tmat4x4<T, P> const & mat,
-		tvec3<T, P> & axis,
+		mat<4, 4, T, P> const& mat,
+		vec<3, T, P> & axis,
 		T & angle
 	)
 	{
@@ -78,54 +78,52 @@ namespace glm
 		axis.z = (mat[0][1] - mat[1][0]) / s;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> axisAngleMatrix
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, P> axisAngleMatrix
 	(
-		tvec3<T, P> const & axis,
+		vec<3, T, P> const & axis,
 		T const angle
 	)
 	{
 		T c = cos(angle);
 		T s = sin(angle);
 		T t = static_cast<T>(1) - c;
-		tvec3<T, P> n = normalize(axis);
+		vec<3, T, P> n = normalize(axis);
 
-		return tmat4x4<T, P>(
+		return mat<4, 4, T, P>(
 			t * n.x * n.x + c,          t * n.x * n.y + n.z * s,    t * n.x * n.z - n.y * s,    T(0),
 			t * n.x * n.y - n.z * s,    t * n.y * n.y + c,          t * n.y * n.z + n.x * s,    T(0),
 			t * n.x * n.z + n.y * s,    t * n.y * n.z - n.x * s,    t * n.z * n.z + c,          T(0),
-			T(0),                        T(0),                        T(0),                     T(1)
-		);
+			T(0),                        T(0),                        T(0),                     T(1));
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> extractMatrixRotation
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, P> extractMatrixRotation
 	(
-		tmat4x4<T, P> const & mat
+		mat<4, 4, T, P> const& m
 	)
 	{
-		return tmat4x4<T, P>(
-			mat[0][0], mat[0][1], mat[0][2], 0.0,
-			mat[1][0], mat[1][1], mat[1][2], 0.0,
-			mat[2][0], mat[2][1], mat[2][2], 0.0,
-			0.0,       0.0,       0.0,       1.0
-		);
+		return mat<4, 4, T, P>(
+			m[0][0], m[0][1], m[0][2], 0.0,
+			m[1][0], m[1][1], m[1][2], 0.0,
+			m[2][0], m[2][1], m[2][2], 0.0,
+			0.0,     0.0,     0.0,     1.0);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> interpolate
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, P> interpolate
 	(
-		tmat4x4<T, P> const & m1,
-		tmat4x4<T, P> const & m2,
+		mat<4, 4, T, P> const& m1,
+		mat<4, 4, T, P> const& m2,
 		T const delta
 	)
 	{
-		tmat4x4<T, P> m1rot = extractMatrixRotation(m1);
-		tmat4x4<T, P> dltRotation = m2 * transpose(m1rot);
-		tvec3<T, P> dltAxis;
+		mat<4, 4, T, P> m1rot = extractMatrixRotation(m1);
+		mat<4, 4, T, P> dltRotation = m2 * transpose(m1rot);
+		vec<3, T, P> dltAxis;
 		T dltAngle;
 		axisAngle(dltRotation, dltAxis, dltAngle);
-		tmat4x4<T, P> out = axisAngleMatrix(dltAxis, dltAngle * delta) * m1rot;
+		mat<4, 4, T, P> out = axisAngleMatrix(dltAxis, dltAngle * delta) * m1rot;
 		out[3][0] = m1[3][0] + delta * (m2[3][0] - m1[3][0]);
 		out[3][1] = m1[3][1] + delta * (m2[3][1] - m1[3][1]);
 		out[3][2] = m1[3][2] + delta * (m2[3][2] - m1[3][2]);
diff --git a/glm/gtx/matrix_major_storage.hpp b/glm/gtx/matrix_major_storage.hpp
index 5a6c47e4..90f57967 100644
--- a/glm/gtx/matrix_major_storage.hpp
+++ b/glm/gtx/matrix_major_storage.hpp
@@ -31,87 +31,87 @@ namespace glm
 
 	//! Build a row major matrix from row vectors.
 	//! From GLM_GTX_matrix_major_storage extension.
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x2<T, P> rowMajor2(
-		tvec2<T, P> const & v1, 
-		tvec2<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<2, 2, T, P> rowMajor2(
+		vec<2, T, P> const & v1, 
+		vec<2, T, P> const & v2);
 		
 	//! Build a row major matrix from other matrix.
 	//! From GLM_GTX_matrix_major_storage extension.
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x2<T, P> rowMajor2(
-		tmat2x2<T, P> const & m);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<2, 2, T, P> rowMajor2(
+		mat<2, 2, T, P> const& m);
 
 	//! Build a row major matrix from row vectors.
 	//! From GLM_GTX_matrix_major_storage extension.
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat3x3<T, P> rowMajor3(
-		tvec3<T, P> const & v1, 
-		tvec3<T, P> const & v2, 
-		tvec3<T, P> const & v3);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<3, 3, T, P> rowMajor3(
+		vec<3, T, P> const & v1, 
+		vec<3, T, P> const & v2, 
+		vec<3, T, P> const & v3);
 
 	//! Build a row major matrix from other matrix.
 	//! From GLM_GTX_matrix_major_storage extension.
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat3x3<T, P> rowMajor3(
-		tmat3x3<T, P> const & m);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<3, 3, T, P> rowMajor3(
+		mat<3, 3, T, P> const& m);
 
 	//! Build a row major matrix from row vectors.
 	//! From GLM_GTX_matrix_major_storage extension.
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat4x4<T, P> rowMajor4(
-		tvec4<T, P> const & v1, 
-		tvec4<T, P> const & v2,
-		tvec4<T, P> const & v3, 
-		tvec4<T, P> const & v4);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<4, 4, T, P> rowMajor4(
+		vec<4, T, P> const & v1, 
+		vec<4, T, P> const & v2,
+		vec<4, T, P> const & v3, 
+		vec<4, T, P> const & v4);
 
 	//! Build a row major matrix from other matrix.
 	//! From GLM_GTX_matrix_major_storage extension.
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat4x4<T, P> rowMajor4(
-		tmat4x4<T, P> const & m);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<4, 4, T, P> rowMajor4(
+		mat<4, 4, T, P> const& m);
 
 	//! Build a column major matrix from column vectors.
 	//! From GLM_GTX_matrix_major_storage extension.
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x2<T, P> colMajor2(
-		tvec2<T, P> const & v1, 
-		tvec2<T, P> const & v2);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<2, 2, T, P> colMajor2(
+		vec<2, T, P> const & v1, 
+		vec<2, T, P> const & v2);
 		
 	//! Build a column major matrix from other matrix.
 	//! From GLM_GTX_matrix_major_storage extension.
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x2<T, P> colMajor2(
-		tmat2x2<T, P> const & m);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<2, 2, T, P> colMajor2(
+		mat<2, 2, T, P> const& m);
 
 	//! Build a column major matrix from column vectors.
 	//! From GLM_GTX_matrix_major_storage extension.
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat3x3<T, P> colMajor3(
-		tvec3<T, P> const & v1, 
-		tvec3<T, P> const & v2, 
-		tvec3<T, P> const & v3);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<3, 3, T, P> colMajor3(
+		vec<3, T, P> const & v1, 
+		vec<3, T, P> const & v2, 
+		vec<3, T, P> const & v3);
 		
 	//! Build a column major matrix from other matrix.
 	//! From GLM_GTX_matrix_major_storage extension.
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat3x3<T, P> colMajor3(
-		tmat3x3<T, P> const & m);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<3, 3, T, P> colMajor3(
+		mat<3, 3, T, P> const& m);
 		
 	//! Build a column major matrix from column vectors.
 	//! From GLM_GTX_matrix_major_storage extension.
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat4x4<T, P> colMajor4(
-		tvec4<T, P> const & v1, 
-		tvec4<T, P> const & v2, 
-		tvec4<T, P> const & v3, 
-		tvec4<T, P> const & v4);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<4, 4, T, P> colMajor4(
+		vec<4, T, P> const & v1, 
+		vec<4, T, P> const & v2, 
+		vec<4, T, P> const & v3, 
+		vec<4, T, P> const & v4);
 				
 	//! Build a column major matrix from other matrix.
 	//! From GLM_GTX_matrix_major_storage extension.
-	template <typename T, precision P> 
-	GLM_FUNC_DECL tmat4x4<T, P> colMajor4(
-		tmat4x4<T, P> const & m);
+	template<typename T, precision P> 
+	GLM_FUNC_DECL mat<4, 4, T, P> colMajor4(
+		mat<4, 4, T, P> const& m);
 
 	/// @}
 }//namespace glm
diff --git a/glm/gtx/matrix_major_storage.inl b/glm/gtx/matrix_major_storage.inl
index 70977390..6a21216f 100644
--- a/glm/gtx/matrix_major_storage.inl
+++ b/glm/gtx/matrix_major_storage.inl
@@ -3,14 +3,14 @@
 
 namespace glm
 {
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat2x2<T, P> rowMajor2
+	template<typename T, precision P> 
+	GLM_FUNC_QUALIFIER mat<2, 2, T, P> rowMajor2
 	(
-		tvec2<T, P> const & v1, 
-		tvec2<T, P> const & v2
+		vec<2, T, P> const & v1, 
+		vec<2, T, P> const & v2
 	)
 	{
-		tmat2x2<T, P> Result;
+		mat<2, 2, T, P> Result;
 		Result[0][0] = v1.x;
 		Result[1][0] = v1.y;
 		Result[0][1] = v2.x;
@@ -18,11 +18,11 @@ namespace glm
 		return Result;
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat2x2<T, P> rowMajor2(
-		const tmat2x2<T, P>& m)
+	template<typename T, precision P> 
+	GLM_FUNC_QUALIFIER mat<2, 2, T, P> rowMajor2(
+		const mat<2, 2, T, P>& m)
 	{
-		tmat2x2<T, P> Result;
+		mat<2, 2, T, P> Result;
 		Result[0][0] = m[0][0];
 		Result[0][1] = m[1][0];
 		Result[1][0] = m[0][1];
@@ -30,13 +30,13 @@ namespace glm
 		return Result;
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat3x3<T, P> rowMajor3(
-		const tvec3<T, P>& v1, 
-		const tvec3<T, P>& v2, 
-		const tvec3<T, P>& v3)
+	template<typename T, precision P> 
+	GLM_FUNC_QUALIFIER mat<3, 3, T, P> rowMajor3(
+		const vec<3, T, P>& v1, 
+		const vec<3, T, P>& v2, 
+		const vec<3, T, P>& v3)
 	{
-		tmat3x3<T, P> Result;
+		mat<3, 3, T, P> Result;
 		Result[0][0] = v1.x;
 		Result[1][0] = v1.y;
 		Result[2][0] = v1.z;
@@ -49,11 +49,11 @@ namespace glm
 		return Result;
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat3x3<T, P> rowMajor3(
-		const tmat3x3<T, P>& m)
+	template<typename T, precision P> 
+	GLM_FUNC_QUALIFIER mat<3, 3, T, P> rowMajor3(
+		const mat<3, 3, T, P>& m)
 	{
-		tmat3x3<T, P> Result;
+		mat<3, 3, T, P> Result;
 		Result[0][0] = m[0][0];
 		Result[0][1] = m[1][0];
 		Result[0][2] = m[2][0];
@@ -66,14 +66,14 @@ namespace glm
 		return Result;
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> rowMajor4(
-		const tvec4<T, P>& v1, 
-		const tvec4<T, P>& v2, 
-		const tvec4<T, P>& v3, 
-		const tvec4<T, P>& v4)
+	template<typename T, precision P> 
+	GLM_FUNC_QUALIFIER mat<4, 4, T, P> rowMajor4(
+		const vec<4, T, P>& v1, 
+		const vec<4, T, P>& v2, 
+		const vec<4, T, P>& v3, 
+		const vec<4, T, P>& v4)
 	{
-		tmat4x4<T, P> Result;
+		mat<4, 4, T, P> Result;
 		Result[0][0] = v1.x;
 		Result[1][0] = v1.y;
 		Result[2][0] = v1.z;
@@ -93,11 +93,11 @@ namespace glm
 		return Result;
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> rowMajor4(
-		const tmat4x4<T, P>& m)
+	template<typename T, precision P> 
+	GLM_FUNC_QUALIFIER mat<4, 4, T, P> rowMajor4(
+		const mat<4, 4, T, P>& m)
 	{
-		tmat4x4<T, P> Result;
+		mat<4, 4, T, P> Result;
 		Result[0][0] = m[0][0];
 		Result[0][1] = m[1][0];
 		Result[0][2] = m[2][0];
@@ -117,51 +117,51 @@ namespace glm
 		return Result;
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat2x2<T, P> colMajor2(
-		const tvec2<T, P>& v1, 
-		const tvec2<T, P>& v2)
+	template<typename T, precision P> 
+	GLM_FUNC_QUALIFIER mat<2, 2, T, P> colMajor2(
+		const vec<2, T, P>& v1, 
+		const vec<2, T, P>& v2)
 	{
-		return tmat2x2<T, P>(v1, v2);
+		return mat<2, 2, T, P>(v1, v2);
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat2x2<T, P> colMajor2(
-		const tmat2x2<T, P>& m)
+	template<typename T, precision P> 
+	GLM_FUNC_QUALIFIER mat<2, 2, T, P> colMajor2(
+		const mat<2, 2, T, P>& m)
 	{
-		return tmat2x2<T, P>(m);
+		return mat<2, 2, T, P>(m);
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat3x3<T, P> colMajor3(
-		const tvec3<T, P>& v1, 
-		const tvec3<T, P>& v2, 
-		const tvec3<T, P>& v3)
+	template<typename T, precision P> 
+	GLM_FUNC_QUALIFIER mat<3, 3, T, P> colMajor3(
+		const vec<3, T, P>& v1, 
+		const vec<3, T, P>& v2, 
+		const vec<3, T, P>& v3)
 	{
-		return tmat3x3<T, P>(v1, v2, v3);
+		return mat<3, 3, T, P>(v1, v2, v3);
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat3x3<T, P> colMajor3(
-		const tmat3x3<T, P>& m)
+	template<typename T, precision P> 
+	GLM_FUNC_QUALIFIER mat<3, 3, T, P> colMajor3(
+		const mat<3, 3, T, P>& m)
 	{
-		return tmat3x3<T, P>(m);
+		return mat<3, 3, T, P>(m);
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> colMajor4(
-		const tvec4<T, P>& v1, 
-		const tvec4<T, P>& v2, 
-		const tvec4<T, P>& v3, 
-		const tvec4<T, P>& v4)
+	template<typename T, precision P> 
+	GLM_FUNC_QUALIFIER mat<4, 4, T, P> colMajor4(
+		const vec<4, T, P>& v1, 
+		const vec<4, T, P>& v2, 
+		const vec<4, T, P>& v3, 
+		const vec<4, T, P>& v4)
 	{
-		return tmat4x4<T, P>(v1, v2, v3, v4);
+		return mat<4, 4, T, P>(v1, v2, v3, v4);
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> colMajor4(
-		const tmat4x4<T, P>& m)
+	template<typename T, precision P> 
+	GLM_FUNC_QUALIFIER mat<4, 4, T, P> colMajor4(
+		const mat<4, 4, T, P>& m)
 	{
-		return tmat4x4<T, P>(m);
+		return mat<4, 4, T, P>(m);
 	}
 }//namespace glm
diff --git a/glm/gtx/matrix_operation.hpp b/glm/gtx/matrix_operation.hpp
index ad209a67..853e27cf 100644
--- a/glm/gtx/matrix_operation.hpp
+++ b/glm/gtx/matrix_operation.hpp
@@ -30,57 +30,57 @@ namespace glm
 
 	//! Build a diagonal matrix.
 	//! From GLM_GTX_matrix_operation extension.
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x2<T, P> diagonal2x2(
-		tvec2<T, P> const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<2, 2, T, P> diagonal2x2(
+		vec<2, T, P> const & v);
 
 	//! Build a diagonal matrix.
 	//! From GLM_GTX_matrix_operation extension.
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x3<T, P> diagonal2x3(
-		tvec2<T, P> const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<2, 3, T, P> diagonal2x3(
+		vec<2, T, P> const & v);
 
 	//! Build a diagonal matrix.
 	//! From GLM_GTX_matrix_operation extension.
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x4<T, P> diagonal2x4(
-		tvec2<T, P> const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<2, 4, T, P> diagonal2x4(
+		vec<2, T, P> const & v);
 
 	//! Build a diagonal matrix.
 	//! From GLM_GTX_matrix_operation extension.
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat3x2<T, P> diagonal3x2(
-		tvec2<T, P> const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<3, 2, T, P> diagonal3x2(
+		vec<2, T, P> const & v);
 
 	//! Build a diagonal matrix.
 	//! From GLM_GTX_matrix_operation extension.
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat3x3<T, P> diagonal3x3(
-		tvec3<T, P> const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<3, 3, T, P> diagonal3x3(
+		vec<3, T, P> const & v);
 
 	//! Build a diagonal matrix.
 	//! From GLM_GTX_matrix_operation extension.
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat3x4<T, P> diagonal3x4(
-		tvec3<T, P> const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<3, 4, T, P> diagonal3x4(
+		vec<3, T, P> const & v);
 
 	//! Build a diagonal matrix.
 	//! From GLM_GTX_matrix_operation extension.
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat4x2<T, P> diagonal4x2(
-		tvec2<T, P> const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<4, 2, T, P> diagonal4x2(
+		vec<2, T, P> const & v);
 
 	//! Build a diagonal matrix.
 	//! From GLM_GTX_matrix_operation extension.
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat4x3<T, P> diagonal4x3(
-		tvec3<T, P> const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<4, 3, T, P> diagonal4x3(
+		vec<3, T, P> const & v);
 
 	//! Build a diagonal matrix.
 	//! From GLM_GTX_matrix_operation extension.
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat4x4<T, P> diagonal4x4(
-		tvec4<T, P> const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<4, 4, T, P> diagonal4x4(
+		vec<4, T, P> const & v);
 
 	/// @}
 }//namespace glm
diff --git a/glm/gtx/matrix_operation.inl b/glm/gtx/matrix_operation.inl
index 15532156..9816d52e 100644
--- a/glm/gtx/matrix_operation.inl
+++ b/glm/gtx/matrix_operation.inl
@@ -3,87 +3,87 @@
 
 namespace glm
 {
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P> diagonal2x2
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<2, 2, T, P> diagonal2x2
 	(
-		tvec2<T, P> const & v
+		vec<2, T, P> const & v
 	)
 	{
-		tmat2x2<T, P> Result(static_cast<T>(1));
+		mat<2, 2, T, P> Result(static_cast<T>(1));
 		Result[0][0] = v[0];
 		Result[1][1] = v[1];
 		return Result;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x3<T, P> diagonal2x3
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<2, 3, T, P> diagonal2x3
 	(
-		tvec2<T, P> const & v
+		vec<2, T, P> const & v
 	)
 	{
-		tmat2x3<T, P> Result(static_cast<T>(1));
+		mat<2, 3, T, P> Result(static_cast<T>(1));
 		Result[0][0] = v[0];
 		Result[1][1] = v[1];
 		return Result;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P> diagonal2x4
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<2, 4, T, P> diagonal2x4
 	(
-		tvec2<T, P> const & v
+		vec<2, T, P> const & v
 	)
 	{
-		tmat2x4<T, P> Result(static_cast<T>(1));
+		mat<2, 4, T, P> Result(static_cast<T>(1));
 		Result[0][0] = v[0];
 		Result[1][1] = v[1];
 		return Result;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x2<T, P> diagonal3x2
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 2, T, P> diagonal3x2
 	(
-		tvec2<T, P> const & v
+		vec<2, T, P> const & v
 	)
 	{
-		tmat3x2<T, P> Result(static_cast<T>(1));
+		mat<3, 2, T, P> Result(static_cast<T>(1));
 		Result[0][0] = v[0];
 		Result[1][1] = v[1];
 		return Result;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x3<T, P> diagonal3x3
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, P> diagonal3x3
 	(
-		tvec3<T, P> const & v
+		vec<3, T, P> const & v
 	)
 	{
-		tmat3x3<T, P> Result(static_cast<T>(1));
+		mat<3, 3, T, P> Result(static_cast<T>(1));
 		Result[0][0] = v[0];
 		Result[1][1] = v[1];
 		Result[2][2] = v[2];
 		return Result;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x4<T, P> diagonal3x4
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 4, T, P> diagonal3x4
 	(
-		tvec3<T, P> const & v
+		vec<3, T, P> const & v
 	)
 	{
-		tmat3x4<T, P> Result(static_cast<T>(1));
+		mat<3, 4, T, P> Result(static_cast<T>(1));
 		Result[0][0] = v[0];
 		Result[1][1] = v[1];
 		Result[2][2] = v[2];
 		return Result;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> diagonal4x4
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, P> diagonal4x4
 	(
-		tvec4<T, P> const & v
+		vec<4, T, P> const & v
 	)
 	{
-		tmat4x4<T, P> Result(static_cast<T>(1));
+		mat<4, 4, T, P> Result(static_cast<T>(1));
 		Result[0][0] = v[0];
 		Result[1][1] = v[1];
 		Result[2][2] = v[2];
@@ -91,26 +91,26 @@ namespace glm
 		return Result;		
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x3<T, P> diagonal4x3
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 3, T, P> diagonal4x3
 	(
-		tvec3<T, P> const & v
+		vec<3, T, P> const & v
 	)
 	{
-		tmat4x3<T, P> Result(static_cast<T>(1));
+		mat<4, 3, T, P> Result(static_cast<T>(1));
 		Result[0][0] = v[0];
 		Result[1][1] = v[1];
 		Result[2][2] = v[2];
 		return Result;		
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x2<T, P> diagonal4x2
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 2, T, P> diagonal4x2
 	(
-		tvec2<T, P> const & v
+		vec<2, T, P> const & v
 	)
 	{
-		tmat4x2<T, P> Result(static_cast<T>(1));
+		mat<4, 2, T, P> Result(static_cast<T>(1));
 		Result[0][0] = v[0];
 		Result[1][1] = v[1];
 		return Result;		
diff --git a/glm/gtx/matrix_query.hpp b/glm/gtx/matrix_query.hpp
index 702cf9f4..f686e6d9 100644
--- a/glm/gtx/matrix_query.hpp
+++ b/glm/gtx/matrix_query.hpp
@@ -34,42 +34,42 @@ namespace glm
 	/// Return whether a matrix a null matrix.
 	/// From GLM_GTX_matrix_query extension.
 	template<typename T, precision P>
-	GLM_FUNC_DECL bool isNull(tmat2x2<T, P> const & m, T const & epsilon);
+	GLM_FUNC_DECL bool isNull(mat<2, 2, T, P> const & m, T const & epsilon);
 		
 	/// Return whether a matrix a null matrix.
 	/// From GLM_GTX_matrix_query extension.
 	template<typename T, precision P>
-	GLM_FUNC_DECL bool isNull(tmat3x3<T, P> const & m, T const & epsilon);
+	GLM_FUNC_DECL bool isNull(mat<3, 3, T, P> const & m, T const & epsilon);
 		
 	/// Return whether a matrix is a null matrix.
 	/// From GLM_GTX_matrix_query extension.
 	template<typename T, precision P>
-	GLM_FUNC_DECL bool isNull(tmat4x4<T, P> const & m, T const & epsilon);
+	GLM_FUNC_DECL bool isNull(mat<4, 4, T, P> const & m, T const & epsilon);
 			
 	/// Return whether a matrix is an identity matrix.
 	/// From GLM_GTX_matrix_query extension.
-	template<typename T, precision P, template <typename, precision> class matType>
-	GLM_FUNC_DECL bool isIdentity(matType<T, P> const & m, T const & epsilon);
+	template<length_t C, length_t R, typename T, precision P, template<length_t, length_t, typename, precision> class matType>
+	GLM_FUNC_DECL bool isIdentity(matType<C, R, T, P> const & m, T const & epsilon);
 
 	/// Return whether a matrix is a normalized matrix.
 	/// From GLM_GTX_matrix_query extension.
 	template<typename T, precision P>
-	GLM_FUNC_DECL bool isNormalized(tmat2x2<T, P> const & m, T const & epsilon);
+	GLM_FUNC_DECL bool isNormalized(mat<2, 2, T, P> const & m, T const & epsilon);
 
 	/// Return whether a matrix is a normalized matrix.
 	/// From GLM_GTX_matrix_query extension.
 	template<typename T, precision P>
-	GLM_FUNC_DECL bool isNormalized(tmat3x3<T, P> const & m, T const & epsilon);
+	GLM_FUNC_DECL bool isNormalized(mat<3, 3, T, P> const & m, T const & epsilon);
 
 	/// Return whether a matrix is a normalized matrix.
 	/// From GLM_GTX_matrix_query extension.
 	template<typename T, precision P>
-	GLM_FUNC_DECL bool isNormalized(tmat4x4<T, P> const & m, T const & epsilon);
+	GLM_FUNC_DECL bool isNormalized(mat<4, 4, T, P> const & m, T const & epsilon);
 
 	/// Return whether a matrix is an orthonormalized matrix.
 	/// From GLM_GTX_matrix_query extension.
-	template<typename T, precision P, template <typename, precision> class matType>
-	GLM_FUNC_DECL bool isOrthogonal(matType<T, P> const & m, T const & epsilon);
+	template<length_t C, length_t R, typename T, precision P, template<length_t, length_t, typename, precision> class matType>
+	GLM_FUNC_DECL bool isOrthogonal(matType<C, R, T, P> const & m, T const & epsilon);
 
 	/// @}
 }//namespace glm
diff --git a/glm/gtx/matrix_query.inl b/glm/gtx/matrix_query.inl
index 491b7741..89cc8a3f 100644
--- a/glm/gtx/matrix_query.inl
+++ b/glm/gtx/matrix_query.inl
@@ -4,7 +4,7 @@
 namespace glm
 {
 	template<typename T, precision P>
-	GLM_FUNC_QUALIFIER bool isNull(tmat2x2<T, P> const & m, T const & epsilon)
+	GLM_FUNC_QUALIFIER bool isNull(mat<2, 2, T, P> const & m, T const & epsilon)
 	{
 		bool result = true;
 		for(length_t i = 0; result && i < m.length() ; ++i)
@@ -13,7 +13,7 @@ namespace glm
 	}
 
 	template<typename T, precision P>
-	GLM_FUNC_QUALIFIER bool isNull(tmat3x3<T, P> const & m, T const & epsilon)
+	GLM_FUNC_QUALIFIER bool isNull(mat<3, 3, T, P> const & m, T const & epsilon)
 	{
 		bool result = true;
 		for(length_t i = 0; result && i < m.length() ; ++i)
@@ -22,7 +22,7 @@ namespace glm
 	}
 
 	template<typename T, precision P>
-	GLM_FUNC_QUALIFIER bool isNull(tmat4x4<T, P> const & m, T const & epsilon)
+	GLM_FUNC_QUALIFIER bool isNull(mat<4, 4, T, P> const & m, T const & epsilon)
 	{
 		bool result = true;
 		for(length_t i = 0; result && i < m.length() ; ++i)
@@ -30,8 +30,8 @@ namespace glm
 		return result;
 	}
 
-	template<typename T, precision P, template <typename, precision> class matType>
-	GLM_FUNC_QUALIFIER bool isIdentity(matType<T, P> const & m, T const & epsilon)
+	template<length_t C, length_t R, typename T, precision P, template<length_t, length_t, typename, precision> class matType>
+	GLM_FUNC_QUALIFIER bool isIdentity(matType<C, R, T, P> const & m, T const & epsilon)
 	{
 		bool result = true;
 		for(length_t i = 0; result && i < m[0].length() ; ++i)
@@ -47,14 +47,14 @@ namespace glm
 	}
 
 	template<typename T, precision P>
-	GLM_FUNC_QUALIFIER bool isNormalized(tmat2x2<T, P> const & m, T const & epsilon)
+	GLM_FUNC_QUALIFIER bool isNormalized(mat<2, 2, T, P> const & m, T const & epsilon)
 	{
 		bool result(true);
 		for(length_t i = 0; result && i < m.length(); ++i)
 			result = isNormalized(m[i], epsilon);
 		for(length_t i = 0; result && i < m.length(); ++i)
 		{
-			typename tmat2x2<T, P>::col_type v;
+			typename mat<2, 2, T, P>::col_type v;
 			for(length_t j = 0; j < m.length(); ++j)
 				v[j] = m[j][i];
 			result = isNormalized(v, epsilon);
@@ -63,14 +63,14 @@ namespace glm
 	}
 
 	template<typename T, precision P>
-	GLM_FUNC_QUALIFIER bool isNormalized(tmat3x3<T, P> const & m, T const & epsilon)
+	GLM_FUNC_QUALIFIER bool isNormalized(mat<3, 3, T, P> const & m, T const & epsilon)
 	{
 		bool result(true);
 		for(length_t i = 0; result && i < m.length(); ++i)
 			result = isNormalized(m[i], epsilon);
 		for(length_t i = 0; result && i < m.length(); ++i)
 		{
-			typename tmat3x3<T, P>::col_type v;
+			typename mat<3, 3, T, P>::col_type v;
 			for(length_t j = 0; j < m.length(); ++j)
 				v[j] = m[j][i];
 			result = isNormalized(v, epsilon);
@@ -79,14 +79,14 @@ namespace glm
 	}
 
 	template<typename T, precision P>
-	GLM_FUNC_QUALIFIER bool isNormalized(tmat4x4<T, P> const & m, T const & epsilon)
+	GLM_FUNC_QUALIFIER bool isNormalized(mat<4, 4, T, P> const & m, T const & epsilon)
 	{
 		bool result(true);
 		for(length_t i = 0; result && i < m.length(); ++i)
 			result = isNormalized(m[i], epsilon);
 		for(length_t i = 0; result && i < m.length(); ++i)
 		{
-			typename tmat4x4<T, P>::col_type v;
+			typename mat<4, 4, T, P>::col_type v;
 			for(length_t j = 0; j < m.length(); ++j)
 				v[j] = m[j][i];
 			result = isNormalized(v, epsilon);
@@ -94,8 +94,8 @@ namespace glm
 		return result;
 	}
 
-	template<typename T, precision P, template <typename, precision> class matType>
-	GLM_FUNC_QUALIFIER bool isOrthogonal(matType<T, P> const & m, T const & epsilon)
+	template<length_t C, length_t R, typename T, precision P, template<length_t, length_t, typename, precision> class matType>
+	GLM_FUNC_QUALIFIER bool isOrthogonal(matType<C, R, T, P> const & m, T const & epsilon)
 	{
 		bool result(true);
 		for(length_t i(0); result && i < m.length() - 1; ++i)
@@ -104,7 +104,7 @@ namespace glm
 
 		if(result)
 		{
-			matType<T, P> tmp = transpose(m);
+			matType<C, R, T, P> tmp = transpose(m);
 			for(length_t i(0); result && i < m.length() - 1 ; ++i)
 			for(length_t j(i + 1); result && j < m.length(); ++j)
 				result = areOrthogonal(tmp[i], tmp[j], epsilon);
diff --git a/glm/gtx/matrix_transform_2d.hpp b/glm/gtx/matrix_transform_2d.hpp
index bb6fc75b..a8be9bc1 100644
--- a/glm/gtx/matrix_transform_2d.hpp
+++ b/glm/gtx/matrix_transform_2d.hpp
@@ -34,45 +34,45 @@ namespace glm
 	///
 	/// @param m Input matrix multiplied by this translation matrix.
 	/// @param v Coordinates of a translation vector.		
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x3<T, P> translate(
-		tmat3x3<T, P> const & m,
-		tvec2<T, P> const & v);
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, P> translate(
+		mat<3, 3, T, P> const& m,
+		vec<2, T, P> const & v);
 
 	/// Builds a rotation 3 * 3 matrix created from an angle. 
 	///
 	/// @param m Input matrix multiplied by this translation matrix.
 	/// @param angle Rotation angle expressed in radians if GLM_FORCE_RADIANS is defined or degrees otherwise.
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat3x3<T, P> rotate(
-		tmat3x3<T, P> const & m,
+	template<typename T, precision P> 
+	GLM_FUNC_QUALIFIER mat<3, 3, T, P> rotate(
+		mat<3, 3, T, P> const& m,
 		T angle);
 
 	/// Builds a scale 3 * 3 matrix created from a vector of 2 components.
 	///
 	/// @param m Input matrix multiplied by this translation matrix.
 	/// @param v Coordinates of a scale vector.		
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat3x3<T, P> scale(
-		tmat3x3<T, P> const & m,
-		tvec2<T, P> const & v);
+	template<typename T, precision P> 
+	GLM_FUNC_QUALIFIER mat<3, 3, T, P> scale(
+		mat<3, 3, T, P> const& m,
+		vec<2, T, P> const & v);
 
 	/// Builds an horizontal (parallel to the x axis) shear 3 * 3 matrix. 
 	///
 	/// @param m Input matrix multiplied by this translation matrix.
 	/// @param y Shear factor.
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat3x3<T, P> shearX(
-		tmat3x3<T, P> const & m,
+	template<typename T, precision P> 
+	GLM_FUNC_QUALIFIER mat<3, 3, T, P> shearX(
+		mat<3, 3, T, P> const& m,
 		T y);
 
 	/// Builds a vertical (parallel to the y axis) shear 3 * 3 matrix. 
 	///
 	/// @param m Input matrix multiplied by this translation matrix.
 	/// @param x Shear factor.
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat3x3<T, P> shearY(
-		tmat3x3<T, P> const & m,
+	template<typename T, precision P> 
+	GLM_FUNC_QUALIFIER mat<3, 3, T, P> shearY(
+		mat<3, 3, T, P> const& m,
 		T x);
 
 	/// @}
diff --git a/glm/gtx/matrix_transform_2d.inl b/glm/gtx/matrix_transform_2d.inl
index bea5670a..97ac720b 100644
--- a/glm/gtx/matrix_transform_2d.inl
+++ b/glm/gtx/matrix_transform_2d.inl
@@ -7,61 +7,61 @@
 namespace glm
 {
 	
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat3x3<T, P> translate(
-		tmat3x3<T, P> const & m,
-		tvec2<T, P> const & v)
+	template<typename T, precision P> 
+	GLM_FUNC_QUALIFIER mat<3, 3, T, P> translate(
+		mat<3, 3, T, P> const& m,
+		vec<2, T, P> const & v)
 	{
-		tmat3x3<T, P> Result(m);
+		mat<3, 3, T, P> Result(m);
 		Result[2] = m[0] * v[0] + m[1] * v[1] + m[2];
 		return Result;
 	}
 
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat3x3<T, P> rotate(
-		tmat3x3<T, P> const & m,
+	template<typename T, precision P> 
+	GLM_FUNC_QUALIFIER mat<3, 3, T, P> rotate(
+		mat<3, 3, T, P> const& m,
 		T angle)
 	{
 		T const a = angle;
 		T const c = cos(a);
 		T const s = sin(a);
 
-		tmat3x3<T, P> Result(uninitialize);
+		mat<3, 3, T, P> Result(uninitialize);
 		Result[0] = m[0] * c + m[1] * s;
 		Result[1] = m[0] * -s + m[1] * c;
 		Result[2] = m[2];
 		return Result;
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat3x3<T, P> scale(
-		tmat3x3<T, P> const & m,
-		tvec2<T, P> const & v)
+	template<typename T, precision P> 
+	GLM_FUNC_QUALIFIER mat<3, 3, T, P> scale(
+		mat<3, 3, T, P> const& m,
+		vec<2, T, P> const & v)
 	{
-		tmat3x3<T, P> Result(uninitialize);
+		mat<3, 3, T, P> Result(uninitialize);
 		Result[0] = m[0] * v[0];
 		Result[1] = m[1] * v[1];
 		Result[2] = m[2];
 		return Result;
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat3x3<T, P> shearX(
-		tmat3x3<T, P> const & m,
+	template<typename T, precision P> 
+	GLM_FUNC_QUALIFIER mat<3, 3, T, P> shearX(
+		mat<3, 3, T, P> const& m,
 		T y)
 	{
-		tmat3x3<T, P> Result(1);
+		mat<3, 3, T, P> Result(1);
 		Result[0][1] = y;
 		return m * Result;
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat3x3<T, P> shearY(
-		tmat3x3<T, P> const & m,
+	template<typename T, precision P> 
+	GLM_FUNC_QUALIFIER mat<3, 3, T, P> shearY(
+		mat<3, 3, T, P> const& m,
 		T x)
 	{
-		tmat3x3<T, P> Result(1);
+		mat<3, 3, T, P> Result(1);
 		Result[1][0] = x;
 		return m * Result;
 	}
diff --git a/glm/gtx/mixed_product.hpp b/glm/gtx/mixed_product.hpp
index e7d3ecc1..4d008939 100644
--- a/glm/gtx/mixed_product.hpp
+++ b/glm/gtx/mixed_product.hpp
@@ -29,11 +29,11 @@ namespace glm
 	/// @{
 
 	/// @brief Mixed product of 3 vectors (from GLM_GTX_mixed_product extension)
-	template <typename T, precision P> 
+	template<typename T, precision P> 
 	GLM_FUNC_DECL T mixedProduct(
-		tvec3<T, P> const & v1, 
-		tvec3<T, P> const & v2, 
-		tvec3<T, P> const & v3);
+		vec<3, T, P> const & v1, 
+		vec<3, T, P> const & v2, 
+		vec<3, T, P> const & v3);
 
 	/// @}
 }// namespace glm
diff --git a/glm/gtx/mixed_product.inl b/glm/gtx/mixed_product.inl
index a6ede596..9fe088de 100644
--- a/glm/gtx/mixed_product.inl
+++ b/glm/gtx/mixed_product.inl
@@ -3,12 +3,12 @@
 
 namespace glm
 {
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER T mixedProduct
 	(
-		tvec3<T, P> const & v1,
-		tvec3<T, P> const & v2,
-		tvec3<T, P> const & v3
+		vec<3, T, P> const & v1,
+		vec<3, T, P> const & v2,
+		vec<3, T, P> const & v3
 	)
 	{
 		return dot(cross(v1, v2), v3);
diff --git a/glm/gtx/norm.hpp b/glm/gtx/norm.hpp
index b8ad79db..729e885a 100644
--- a/glm/gtx/norm.hpp
+++ b/glm/gtx/norm.hpp
@@ -32,56 +32,56 @@ namespace glm
 
 	/// Returns the squared length of x.
 	/// From GLM_GTX_norm extension.
-	template <typename T, precision P, template <typename, precision> class vecType>
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
 	GLM_FUNC_DECL T length2(
-		vecType<T, P> const & x);
+		vecType<L, T, P> const& x);
 
 	/// Returns the squared distance between p0 and p1, i.e., length2(p0 - p1).
 	/// From GLM_GTX_norm extension.
-	template <typename T, precision P, template <typename, precision> class vecType>
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
 	GLM_FUNC_DECL T distance2(
-		vecType<T, P> const & p0,
-		vecType<T, P> const & p1);
+		vecType<L, T, P> const& p0,
+		vecType<L, T, P> const& p1);
 
 	//! Returns the L1 norm between x and y.
 	//! From GLM_GTX_norm extension.
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_DECL T l1Norm(
-		tvec3<T, P> const & x,
-		tvec3<T, P> const & y);
+		vec<3, T, P> const & x,
+		vec<3, T, P> const & y);
 		
 	//! Returns the L1 norm of v.
 	//! From GLM_GTX_norm extension.
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_DECL T l1Norm(
-		tvec3<T, P> const & v);
+		vec<3, T, P> const & v);
 		
 	//! Returns the L2 norm between x and y.
 	//! From GLM_GTX_norm extension.
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_DECL T l2Norm(
-		tvec3<T, P> const & x,
-		tvec3<T, P> const & y);
+		vec<3, T, P> const & x,
+		vec<3, T, P> const & y);
 		
 	//! Returns the L2 norm of v.
 	//! From GLM_GTX_norm extension.
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_DECL T l2Norm(
-		tvec3<T, P> const & x);
+		vec<3, T, P> const & x);
 		
 	//! Returns the L norm between x and y.
 	//! From GLM_GTX_norm extension.
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_DECL T lxNorm(
-		tvec3<T, P> const & x,
-		tvec3<T, P> const & y,
+		vec<3, T, P> const & x,
+		vec<3, T, P> const & y,
 		unsigned int Depth);
 
 	//! Returns the L norm of v.
 	//! From GLM_GTX_norm extension.
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_DECL T lxNorm(
-		tvec3<T, P> const & x,
+		vec<3, T, P> const & x,
 		unsigned int Depth);
 
 	/// @}
diff --git a/glm/gtx/norm.inl b/glm/gtx/norm.inl
index 20954ec7..49b6a008 100644
--- a/glm/gtx/norm.inl
+++ b/glm/gtx/norm.inl
@@ -6,97 +6,97 @@
 namespace glm{
 namespace detail
 {
-	template <template <typename, precision> class vecType, typename T, precision P, bool Aligned>
+	template<template<length_t, typename, precision> class vecType, length_t L, typename T, precision P, bool Aligned>
 	struct compute_length2
 	{
-		GLM_FUNC_QUALIFIER static T call(vecType<T, P> const & v)
+		GLM_FUNC_QUALIFIER static T call(vecType<L, T, P> const & v)
 		{
 			return dot(v, v);
 		}
 	};
 }//namespace detail
 
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER genType length2(genType x)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'length2' accepts only floating-point inputs");
 		return x * x;
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER T length2(vecType<T, P> const & v)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER T length2(vecType<L, T, P> const & v)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'length2' accepts only floating-point inputs");
-		return detail::compute_length2<vecType, T, P, detail::is_aligned<P>::value>::call(v);
+		return detail::compute_length2<vecType, L, T, P, detail::is_aligned<P>::value>::call(v);
 	}
 
-	template <typename T>
+	template<typename T>
 	GLM_FUNC_QUALIFIER T distance2(T p0, T p1)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'distance2' accepts only floating-point inputs");
 		return length2(p1 - p0);
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER T distance2(vecType<T, P> const & p0, vecType<T, P> const & p1)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER T distance2(vecType<L, T, P> const & p0, vecType<L, T, P> const & p1)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'distance2' accepts only floating-point inputs");
 		return length2(p1 - p0);
 	}
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER T l1Norm
 	(
-		tvec3<T, P> const & a,
-		tvec3<T, P> const & b
+		vec<3, T, P> const & a,
+		vec<3, T, P> const & b
 	)
 	{
 		return abs(b.x - a.x) + abs(b.y - a.y) + abs(b.z - a.z);
 	}
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER T l1Norm
 	(
-		tvec3<T, P> const & v
+		vec<3, T, P> const & v
 	)
 	{
 		return abs(v.x) + abs(v.y) + abs(v.z);
 	}
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER T l2Norm
 	(
-		tvec3<T, P> const & a,
-		tvec3<T, P> const & b
+		vec<3, T, P> const & a,
+		vec<3, T, P> const & b
 	)
 	{
 		return length(b - a);
 	}
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER T l2Norm
 	(
-		tvec3<T, P> const & v
+		vec<3, T, P> const & v
 	)
 	{
 		return length(v);
 	}
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER T lxNorm
 	(
-		tvec3<T, P> const & x,
-		tvec3<T, P> const & y,
+		vec<3, T, P> const & x,
+		vec<3, T, P> const & y,
 		unsigned int Depth
 	)
 	{
 		return pow(pow(y.x - x.x, T(Depth)) + pow(y.y - x.y, T(Depth)) + pow(y.z - x.z, T(Depth)), T(1) / T(Depth));
 	}
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER T lxNorm
 	(
-		tvec3<T, P> const & v,
+		vec<3, T, P> const & v,
 		unsigned int Depth
 	)
 	{
diff --git a/glm/gtx/normal.hpp b/glm/gtx/normal.hpp
index 7a12dbaf..cd99000a 100644
--- a/glm/gtx/normal.hpp
+++ b/glm/gtx/normal.hpp
@@ -31,11 +31,11 @@ namespace glm
 
 	//! Computes triangle normal from triangle points. 
 	//! From GLM_GTX_normal extension.
-	template <typename T, precision P> 
-	GLM_FUNC_DECL tvec3<T, P> triangleNormal(
-		tvec3<T, P> const & p1, 
-		tvec3<T, P> const & p2, 
-		tvec3<T, P> const & p3);
+	template<typename T, precision P> 
+	GLM_FUNC_DECL vec<3, T, P> triangleNormal(
+		vec<3, T, P> const & p1, 
+		vec<3, T, P> const & p2, 
+		vec<3, T, P> const & p3);
 
 	/// @}
 }//namespace glm
diff --git a/glm/gtx/normal.inl b/glm/gtx/normal.inl
index e4423176..cdb31dca 100644
--- a/glm/gtx/normal.inl
+++ b/glm/gtx/normal.inl
@@ -3,12 +3,12 @@
 
 namespace glm
 {
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tvec3<T, P> triangleNormal
+	template<typename T, precision P> 
+	GLM_FUNC_QUALIFIER vec<3, T, P> triangleNormal
 	(
-		tvec3<T, P> const & p1, 
-		tvec3<T, P> const & p2, 
-		tvec3<T, P> const & p3
+		vec<3, T, P> const & p1, 
+		vec<3, T, P> const & p2, 
+		vec<3, T, P> const & p3
 	)
 	{
 		return normalize(cross(p1 - p2, p1 - p3));
diff --git a/glm/gtx/normalize_dot.hpp b/glm/gtx/normalize_dot.hpp
index 0c2101ba..a4977d90 100644
--- a/glm/gtx/normalize_dot.hpp
+++ b/glm/gtx/normalize_dot.hpp
@@ -33,15 +33,15 @@ namespace glm
 	/// It's faster that dot(normalize(x), normalize(y)).
 	///
 	/// @see gtx_normalize_dot extension.
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL T normalizeDot(vecType<T, P> const & x, vecType<T, P> const & y);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL T normalizeDot(vecType<L, T, P> const & x, vecType<L, T, P> const & y);
 
 	/// Normalize parameters and returns the dot product of x and y.
 	/// Faster that dot(fastNormalize(x), fastNormalize(y)).
 	///
 	/// @see gtx_normalize_dot extension.
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL T fastNormalizeDot(vecType<T, P> const & x, vecType<T, P> const & y);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL T fastNormalizeDot(vecType<L, T, P> const & x, vecType<L, T, P> const & y);
 
 	/// @}
 }//namespace glm
diff --git a/glm/gtx/normalize_dot.inl b/glm/gtx/normalize_dot.inl
index 0d01ffe2..0a90aaf2 100644
--- a/glm/gtx/normalize_dot.inl
+++ b/glm/gtx/normalize_dot.inl
@@ -3,14 +3,14 @@
 
 namespace glm
 {
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER T normalizeDot(vecType<T, P> const & x, vecType<T, P> const & y)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER T normalizeDot(vecType<L, T, P> const & x, vecType<L, T, P> const & y)
 	{
 		return glm::dot(x, y) * glm::inversesqrt(glm::dot(x, x) * glm::dot(y, y));
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER T fastNormalizeDot(vecType<T, P> const & x, vecType<T, P> const & y)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER T fastNormalizeDot(vecType<L, T, P> const & x, vecType<L, T, P> const & y)
 	{
 		return glm::dot(x, y) * glm::fastInverseSqrt(glm::dot(x, x) * glm::dot(y, y));
 	}
diff --git a/glm/gtx/optimum_pow.hpp b/glm/gtx/optimum_pow.hpp
index da1a20c3..849e8195 100644
--- a/glm/gtx/optimum_pow.hpp
+++ b/glm/gtx/optimum_pow.hpp
@@ -32,19 +32,19 @@ namespace gtx
 	/// Returns x raised to the power of 2.
 	///
 	/// @see gtx_optimum_pow
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL genType pow2(genType const & x);
 
 	/// Returns x raised to the power of 3.
 	///
 	/// @see gtx_optimum_pow
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL genType pow3(genType const & x);
 
 	/// Returns x raised to the power of 4.
 	///
 	/// @see gtx_optimum_pow
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL genType pow4(genType const & x);
 
 	/// @}
diff --git a/glm/gtx/optimum_pow.inl b/glm/gtx/optimum_pow.inl
index 2216a743..2e933a23 100644
--- a/glm/gtx/optimum_pow.inl
+++ b/glm/gtx/optimum_pow.inl
@@ -3,19 +3,19 @@
 
 namespace glm
 {
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER genType pow2(genType const & x)
 	{
 		return x * x;
 	}
 
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER genType pow3(genType const & x)
 	{
 		return x * x * x;
 	}
 
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER genType pow4(genType const & x)
 	{
 		return (x * x) * (x * x);
diff --git a/glm/gtx/orthonormalize.hpp b/glm/gtx/orthonormalize.hpp
index 75b8ae8e..562de142 100644
--- a/glm/gtx/orthonormalize.hpp
+++ b/glm/gtx/orthonormalize.hpp
@@ -34,14 +34,14 @@ namespace glm
 	/// Returns the orthonormalized matrix of m.
 	///
 	/// @see gtx_orthonormalize
-	template <typename T, precision P> 
-	GLM_FUNC_DECL tmat3x3<T, P> orthonormalize(tmat3x3<T, P> const & m);
+	template<typename T, precision P> 
+	GLM_FUNC_DECL mat<3, 3, T, P> orthonormalize(mat<3, 3, T, P> const & m);
 		
 	/// Orthonormalizes x according y.
 	///
 	/// @see gtx_orthonormalize
-	template <typename T, precision P> 
-	GLM_FUNC_DECL tvec3<T, P> orthonormalize(tvec3<T, P> const & x, tvec3<T, P> const & y);
+	template<typename T, precision P> 
+	GLM_FUNC_DECL vec<3, T, P> orthonormalize(vec<3, T, P> const & x, vec<3, T, P> const & y);
 
 	/// @}
 }//namespace glm
diff --git a/glm/gtx/orthonormalize.inl b/glm/gtx/orthonormalize.inl
index 4796384e..ebdee8c6 100644
--- a/glm/gtx/orthonormalize.inl
+++ b/glm/gtx/orthonormalize.inl
@@ -3,10 +3,10 @@
 
 namespace glm
 {
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x3<T, P> orthonormalize(tmat3x3<T, P> const & m)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, P> orthonormalize(mat<3, 3, T, P> const & m)
 	{
-		tmat3x3<T, P> r = m;
+		mat<3, 3, T, P> r = m;
 
 		r[0] = normalize(r[0]);
 
@@ -22,8 +22,8 @@ namespace glm
 		return r;
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tvec3<T, P> orthonormalize(tvec3<T, P> const & x, tvec3<T, P> const & y)
+	template<typename T, precision P> 
+	GLM_FUNC_QUALIFIER vec<3, T, P> orthonormalize(vec<3, T, P> const & x, vec<3, T, P> const & y)
 	{
 		return normalize(x - y * dot(y, x));
 	}
diff --git a/glm/gtx/perpendicular.hpp b/glm/gtx/perpendicular.hpp
index 040899ff..7fe3f5bb 100644
--- a/glm/gtx/perpendicular.hpp
+++ b/glm/gtx/perpendicular.hpp
@@ -32,7 +32,7 @@ namespace glm
 
 	//! Projects x a perpendicular axis of Normal.
 	//! From GLM_GTX_perpendicular extension.
-	template <typename vecType> 
+	template<typename vecType> 
 	GLM_FUNC_DECL vecType perp(
 		vecType const & x, 
 		vecType const & Normal);
diff --git a/glm/gtx/perpendicular.inl b/glm/gtx/perpendicular.inl
index 08a7a815..e490bdd9 100644
--- a/glm/gtx/perpendicular.inl
+++ b/glm/gtx/perpendicular.inl
@@ -3,7 +3,7 @@
 
 namespace glm
 {
-	template <typename vecType> 
+	template<typename vecType> 
 	GLM_FUNC_QUALIFIER vecType perp
 	(
 		vecType const & x, 
diff --git a/glm/gtx/polar_coordinates.hpp b/glm/gtx/polar_coordinates.hpp
index 9a3387f5..a25fddc2 100644
--- a/glm/gtx/polar_coordinates.hpp
+++ b/glm/gtx/polar_coordinates.hpp
@@ -31,16 +31,16 @@ namespace glm
 	/// Convert Euclidean to Polar coordinates, x is the xz distance, y, the latitude and z the longitude.
 	///
 	/// @see gtx_polar_coordinates
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> polar(
-		tvec3<T, P> const & euclidean);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<3, T, P> polar(
+		vec<3, T, P> const & euclidean);
 
 	/// Convert Polar to Euclidean coordinates.
 	///
 	/// @see gtx_polar_coordinates
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> euclidean(
-		tvec2<T, P> const & polar);
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<3, T, P> euclidean(
+		vec<2, T, P> const & polar);
 
 	/// @}
 }//namespace glm
diff --git a/glm/gtx/polar_coordinates.inl b/glm/gtx/polar_coordinates.inl
index afc9d2bc..c4e394f5 100644
--- a/glm/gtx/polar_coordinates.inl
+++ b/glm/gtx/polar_coordinates.inl
@@ -3,32 +3,32 @@
 
 namespace glm
 {
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> polar
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> polar
 	(
-		tvec3<T, P> const & euclidean
+		vec<3, T, P> const & euclidean
 	)
 	{
 		T const Length(length(euclidean));
-		tvec3<T, P> const tmp(euclidean / Length);
+		vec<3, T, P> const tmp(euclidean / Length);
 		T const xz_dist(sqrt(tmp.x * tmp.x + tmp.z * tmp.z));
 
-		return tvec3<T, P>(
+		return vec<3, T, P>(
 			asin(tmp.y),	// latitude
 			atan(tmp.x, tmp.z),		// longitude
 			xz_dist);				// xz distance
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> euclidean
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> euclidean
 	(
-		tvec2<T, P> const & polar
+		vec<2, T, P> const & polar
 	)
 	{
 		T const latitude(polar.x);
 		T const longitude(polar.y);
 
-		return tvec3<T, P>(
+		return vec<3, T, P>(
 			cos(latitude) * sin(longitude),
 			sin(latitude),
 			cos(latitude) * cos(longitude));
diff --git a/glm/gtx/projection.hpp b/glm/gtx/projection.hpp
index ad55f1c0..cab35bf9 100644
--- a/glm/gtx/projection.hpp
+++ b/glm/gtx/projection.hpp
@@ -31,7 +31,7 @@ namespace glm
 	/// Projects x on Normal.
 	///
 	/// @see gtx_projection
-	template <typename vecType>
+	template<typename vecType>
 	GLM_FUNC_DECL vecType proj(vecType const & x, vecType const & Normal);
 
 	/// @}
diff --git a/glm/gtx/projection.inl b/glm/gtx/projection.inl
index d21fe83d..8368669b 100644
--- a/glm/gtx/projection.inl
+++ b/glm/gtx/projection.inl
@@ -3,7 +3,7 @@
 
 namespace glm
 {
-	template <typename vecType>
+	template<typename vecType>
 	GLM_FUNC_QUALIFIER vecType proj(vecType const & x, vecType const & Normal)
 	{
 		return glm::dot(x, Normal) / glm::dot(Normal, Normal) * Normal;
diff --git a/glm/gtx/quaternion.hpp b/glm/gtx/quaternion.hpp
index 475e1c4d..ad298dae 100644
--- a/glm/gtx/quaternion.hpp
+++ b/glm/gtx/quaternion.hpp
@@ -36,16 +36,16 @@ namespace glm
 	///
 	/// @see gtx_quaternion
 	template<typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> cross(
+	GLM_FUNC_DECL vec<3, T, P> cross(
 		tquat<T, P> const & q,
-		tvec3<T, P> const & v);
+		vec<3, T, P> const & v);
 
 	//! Compute a cross product between a vector and a quaternion.
 	///
 	/// @see gtx_quaternion
 	template<typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> cross(
-		tvec3<T, P> const & v,
+	GLM_FUNC_DECL vec<3, T, P> cross(
+		vec<3, T, P> const & v,
 		tquat<T, P> const & q);
 
 	//! Compute a point on a path according squad equation. 
@@ -102,17 +102,17 @@ namespace glm
 	///
 	/// @see gtx_quaternion
 	template<typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> rotate(
+	GLM_FUNC_DECL vec<3, T, P> rotate(
 		tquat<T, P> const & q,
-		tvec3<T, P> const & v);
+		vec<3, T, P> const & v);
 
 	/// Rotates a 4 components vector by a quaternion.
 	///
 	/// @see gtx_quaternion
 	template<typename T, precision P>
-	GLM_FUNC_DECL tvec4<T, P> rotate(
+	GLM_FUNC_DECL vec<4, T, P> rotate(
 		tquat<T, P> const & q,
-		tvec4<T, P> const & v);
+		vec<4, T, P> const & v);
 
 	/// Extract the real component of a quaternion.
 	///
@@ -125,14 +125,14 @@ namespace glm
 	///
 	/// @see gtx_quaternion
 	template<typename T, precision P>
-	GLM_FUNC_DECL tmat3x3<T, P> toMat3(
+	GLM_FUNC_DECL mat<3, 3, T, P> toMat3(
 		tquat<T, P> const & x){return mat3_cast(x);}
 
 	/// Converts a quaternion to a 4 * 4 matrix.
 	///
 	/// @see gtx_quaternion
 	template<typename T, precision P>
-	GLM_FUNC_DECL tmat4x4<T, P> toMat4(
+	GLM_FUNC_DECL mat<4, 4, T, P> toMat4(
 		tquat<T, P> const & x){return mat4_cast(x);}
 
 	/// Converts a 3 * 3 matrix to a quaternion.
@@ -140,14 +140,14 @@ namespace glm
 	/// @see gtx_quaternion
 	template<typename T, precision P>
 	GLM_FUNC_DECL tquat<T, P> toQuat(
-		tmat3x3<T, P> const & x){return quat_cast(x);}
+		mat<3, 3, T, P> const& x){return quat_cast(x);}
 
 	/// Converts a 4 * 4 matrix to a quaternion.
 	///
 	/// @see gtx_quaternion
 	template<typename T, precision P>
 	GLM_FUNC_DECL tquat<T, P> toQuat(
-		tmat4x4<T, P> const & x){return quat_cast(x);}
+		mat<4, 4, T, P> const& x){return quat_cast(x);}
 
 	/// Quaternion interpolation using the rotation short path.
 	///
@@ -174,8 +174,8 @@ namespace glm
 	/// @see gtx_quaternion
 	template<typename T, precision P>
 	GLM_FUNC_DECL tquat<T, P> rotation(
-		tvec3<T, P> const & orig, 
-		tvec3<T, P> const & dest);
+		vec<3, T, P> const & orig, 
+		vec<3, T, P> const & dest);
 
 	/// Returns the squared length of x.
 	/// 
diff --git a/glm/gtx/quaternion.inl b/glm/gtx/quaternion.inl
index c86ec187..7bdcdf60 100644
--- a/glm/gtx/quaternion.inl
+++ b/glm/gtx/quaternion.inl
@@ -6,19 +6,19 @@
 
 namespace glm
 {
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> cross(tvec3<T, P> const& v, tquat<T, P> const& q)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> cross(vec<3, T, P> const& v, tquat<T, P> const& q)
 	{
 		return inverse(q) * v;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> cross(tquat<T, P> const& q, tvec3<T, P> const& v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> cross(tquat<T, P> const& q, vec<3, T, P> const& v)
 	{
 		return q * v;
 	}
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER tquat<T, P> squad
 	(
 		tquat<T, P> const & q1,
@@ -30,7 +30,7 @@ namespace glm
 		return mix(mix(q1, q2, h), mix(s1, s2, h), static_cast<T>(2) * (static_cast<T>(1) - h) * h);
 	}
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER tquat<T, P> intermediate
 	(
 		tquat<T, P> const & prev,
@@ -42,22 +42,22 @@ namespace glm
 		return exp((log(next + invQuat) + log(prev + invQuat)) / static_cast<T>(-4)) * curr;
 	}
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER tquat<T, P> exp(tquat<T, P> const& q)
 	{
-		tvec3<T, P> u(q.x, q.y, q.z);
+		vec<3, T, P> u(q.x, q.y, q.z);
 		T const Angle = glm::length(u);
 		if (Angle < epsilon<T>())
 			return tquat<T, P>();
 
-		tvec3<T, P> const v(u / Angle);
+		vec<3, T, P> const v(u / Angle);
 		return tquat<T, P>(cos(Angle), sin(Angle) * v);
 	}
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER tquat<T, P> log(tquat<T, P> const& q)
 	{
-		tvec3<T, P> u(q.x, q.y, q.z);
+		vec<3, T, P> u(q.x, q.y, q.z);
 		T Vec3Len = length(u);
 
 		if (Vec3Len < epsilon<T>())
@@ -77,7 +77,7 @@ namespace glm
 		}
 	}
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER tquat<T, P> pow(tquat<T, P> const & x, T const & y)
 	{
 		//Raising to the power of 0 should yield 1
@@ -101,19 +101,19 @@ namespace glm
 		return tquat<T, P>(cos(NewAngle) * magnitude * Mag, x.x * Div * Mag, x.y * Div * Mag, x.z * Div * Mag);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> rotate(tquat<T, P> const& q, tvec3<T, P> const& v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> rotate(tquat<T, P> const& q, vec<3, T, P> const& v)
 	{
 		return q * v;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> rotate(tquat<T, P> const& q, tvec4<T, P> const& v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, T, P> rotate(tquat<T, P> const& q, vec<4, T, P> const& v)
 	{
 		return q * v;
 	}
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER T extractRealComponent(tquat<T, P> const& q)
 	{
 		T w = static_cast<T>(1) - q.x * q.x - q.y * q.y - q.z * q.z;
@@ -123,13 +123,13 @@ namespace glm
 			return -sqrt(w);
 	}
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER T length2(tquat<T, P> const& q)
 	{
 		return q.x * q.x + q.y * q.y + q.z * q.z + q.w * q.w;
 	}
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER tquat<T, P> shortMix(tquat<T, P> const& x, tquat<T, P> const& y, T const& a)
 	{
 		if(a <= static_cast<T>(0)) return x;
@@ -166,17 +166,17 @@ namespace glm
 			k0 * x.z + k1 * y2.z);
 	}
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER tquat<T, P> fastMix(tquat<T, P> const& x, tquat<T, P> const& y, T const & a)
 	{
 		return glm::normalize(x * (static_cast<T>(1) - a) + (y * a));
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tquat<T, P> rotation(tvec3<T, P> const& orig, tvec3<T, P> const& dest)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER tquat<T, P> rotation(vec<3, T, P> const& orig, vec<3, T, P> const& dest)
 	{
 		T cosTheta = dot(orig, dest);
-		tvec3<T, P> rotationAxis;
+		vec<3, T, P> rotationAxis;
 
 		if(cosTheta >= static_cast<T>(1) - epsilon<T>())
 			return quat();
@@ -188,9 +188,9 @@ namespace glm
 			// So guess one; any will do as long as it's perpendicular to start
 			// This implementation favors a rotation around the Up axis (Y),
 			// since it's often what you want to do.
-			rotationAxis = cross(tvec3<T, P>(0, 0, 1), orig);
+			rotationAxis = cross(vec<3, T, P>(0, 0, 1), orig);
 			if(length2(rotationAxis) < epsilon<T>()) // bad luck, they were parallel, try again!
-				rotationAxis = cross(tvec3<T, P>(1, 0, 0), orig);
+				rotationAxis = cross(vec<3, T, P>(1, 0, 0), orig);
 
 			rotationAxis = normalize(rotationAxis);
 			return angleAxis(pi<T>(), rotationAxis);
diff --git a/glm/gtx/range.hpp b/glm/gtx/range.hpp
index db438989..0877b2e4 100644
--- a/glm/gtx/range.hpp
+++ b/glm/gtx/range.hpp
@@ -31,55 +31,55 @@ namespace glm
 	/// @addtogroup gtx_range
 	/// @{
 
-	template <typename T, precision P>
-	inline length_t components(tvec1<T, P> const & v)
+	template<typename T, precision P>
+	inline length_t components(vec<1, T, P> const & v)
 	{
 		return v.length();
 	}
 	
-	template <typename T, precision P>
-	inline length_t components(tvec2<T, P> const & v)
+	template<typename T, precision P>
+	inline length_t components(vec<2, T, P> const & v)
 	{
 		return v.length();
 	}
 	
-	template <typename T, precision P>
-	inline length_t components(tvec3<T, P> const & v)
+	template<typename T, precision P>
+	inline length_t components(vec<3, T, P> const & v)
 	{
 		return v.length();
 	}
 	
-	template <typename T, precision P>
-	inline length_t components(tvec4<T, P> const & v)
+	template<typename T, precision P>
+	inline length_t components(vec<4, T, P> const & v)
 	{
 		return v.length();
 	}
 	
-	template <typename genType>
+	template<typename genType>
 	inline length_t components(genType const & m)
 	{
 		return m.length() * m[0].length();
 	}
 	
-	template <typename genType>
+	template<typename genType>
 	inline typename genType::value_type const * begin(genType const & v)
 	{
 		return value_ptr(v);
 	}
 
-	template <typename genType>
+	template<typename genType>
 	inline typename genType::value_type const * end(genType const & v)
 	{
 		return begin(v) + components(v);
 	}
 
-	template <typename genType>
+	template<typename genType>
 	inline typename genType::value_type * begin(genType& v)
 	{
 		return value_ptr(v);
 	}
 
-	template <typename genType>
+	template<typename genType>
 	inline typename genType::value_type * end(genType& v)
 	{
 		return begin(v) + components(v);
diff --git a/glm/gtx/rotate_normalized_axis.hpp b/glm/gtx/rotate_normalized_axis.hpp
index b03def21..229606f5 100644
--- a/glm/gtx/rotate_normalized_axis.hpp
+++ b/glm/gtx/rotate_normalized_axis.hpp
@@ -41,13 +41,13 @@ namespace glm
 	/// 
 	/// @see gtx_rotate_normalized_axis
 	/// @see - rotate(T angle, T x, T y, T z) 
-	/// @see - rotate(tmat4x4<T, P> const & m, T angle, T x, T y, T z) 
-	/// @see - rotate(T angle, tvec3<T, P> const & v) 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat4x4<T, P> rotateNormalizedAxis(
-		tmat4x4<T, P> const & m,
+	/// @see - rotate(mat<4, 4, T, P> const & m, T angle, T x, T y, T z) 
+	/// @see - rotate(T angle, vec<3, T, P> const & v) 
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<4, 4, T, P> rotateNormalizedAxis(
+		mat<4, 4, T, P> const& m,
 		T const & angle,
-		tvec3<T, P> const & axis);
+		vec<3, T, P> const & axis);
 
 	/// Rotates a quaternion from a vector of 3 components normalized axis and an angle.
 	/// 
@@ -56,11 +56,11 @@ namespace glm
 	/// @param axis Normalized axis of the rotation, must be normalized.
 	/// 
 	/// @see gtx_rotate_normalized_axis
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_DECL tquat<T, P> rotateNormalizedAxis(
 		tquat<T, P> const & q,
 		T const & angle,
-		tvec3<T, P> const & axis);
+		vec<3, T, P> const & axis);
 
 	/// @}
 }//namespace glm
diff --git a/glm/gtx/rotate_normalized_axis.inl b/glm/gtx/rotate_normalized_axis.inl
index dc1b1a85..6cfb21b2 100644
--- a/glm/gtx/rotate_normalized_axis.inl
+++ b/glm/gtx/rotate_normalized_axis.inl
@@ -3,23 +3,23 @@
 
 namespace glm
 {
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> rotateNormalizedAxis
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, P> rotateNormalizedAxis
 	(
-		tmat4x4<T, P> const & m,
+		mat<4, 4, T, P> const& m,
 		T const & angle,
-		tvec3<T, P> const & v
+		vec<3, T, P> const & v
 	)
 	{
 		T const a = angle;
 		T const c = cos(a);
 		T const s = sin(a);
 
-		tvec3<T, P> const axis(v);
+		vec<3, T, P> const axis(v);
 
-		tvec3<T, P> const temp((static_cast<T>(1) - c) * axis);
+		vec<3, T, P> const temp((static_cast<T>(1) - c) * axis);
 
-		tmat4x4<T, P> Rotate(uninitialize);
+		mat<4, 4, T, P> Rotate(uninitialize);
 		Rotate[0][0] = c + temp[0] * axis[0];
 		Rotate[0][1] = 0 + temp[0] * axis[1] + s * axis[2];
 		Rotate[0][2] = 0 + temp[0] * axis[2] - s * axis[1];
@@ -32,7 +32,7 @@ namespace glm
 		Rotate[2][1] = 0 + temp[2] * axis[1] - s * axis[0];
 		Rotate[2][2] = c + temp[2] * axis[2];
 
-		tmat4x4<T, P> Result(uninitialize);
+		mat<4, 4, T, P> Result(uninitialize);
 		Result[0] = m[0] * Rotate[0][0] + m[1] * Rotate[0][1] + m[2] * Rotate[0][2];
 		Result[1] = m[0] * Rotate[1][0] + m[1] * Rotate[1][1] + m[2] * Rotate[1][2];
 		Result[2] = m[0] * Rotate[2][0] + m[1] * Rotate[2][1] + m[2] * Rotate[2][2];
@@ -40,15 +40,15 @@ namespace glm
 		return Result;
 	}
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER tquat<T, P> rotateNormalizedAxis
 	(
 		tquat<T, P> const & q, 
 		T const & angle,
-		tvec3<T, P> const & v
+		vec<3, T, P> const & v
 	)
 	{
-		tvec3<T, P> const Tmp(v);
+		vec<3, T, P> const Tmp(v);
 
 		T const AngleRad(angle);
 		T const Sin = sin(AngleRad * T(0.5));
diff --git a/glm/gtx/rotate_vector.hpp b/glm/gtx/rotate_vector.hpp
index 246a01ec..a1f1ffe9 100644
--- a/glm/gtx/rotate_vector.hpp
+++ b/glm/gtx/rotate_vector.hpp
@@ -37,83 +37,83 @@ namespace glm
 	/// @param a Interpolation factor. The interpolation is defined beyond the range [0, 1].
 	/// 
 	/// @see gtx_rotate_vector
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> slerp(
-		tvec3<T, P> const & x,
-		tvec3<T, P> const & y,
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<3, T, P> slerp(
+		vec<3, T, P> const & x,
+		vec<3, T, P> const & y,
 		T const & a);
 
 	//! Rotate a two dimensional vector.
 	//! From GLM_GTX_rotate_vector extension.
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec2<T, P> rotate(
-		tvec2<T, P> const & v,
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<2, T, P> rotate(
+		vec<2, T, P> const & v,
 		T const & angle);
 		
 	//! Rotate a three dimensional vector around an axis.
 	//! From GLM_GTX_rotate_vector extension.
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> rotate(
-		tvec3<T, P> const & v,
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<3, T, P> rotate(
+		vec<3, T, P> const & v,
 		T const & angle,
-		tvec3<T, P> const & normal);
+		vec<3, T, P> const & normal);
 		
 	//! Rotate a four dimensional vector around an axis.
 	//! From GLM_GTX_rotate_vector extension.
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec4<T, P> rotate(
-		tvec4<T, P> const & v,
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<4, T, P> rotate(
+		vec<4, T, P> const & v,
 		T const & angle,
-		tvec3<T, P> const & normal);
+		vec<3, T, P> const & normal);
 		
 	//! Rotate a three dimensional vector around the X axis.
 	//! From GLM_GTX_rotate_vector extension.
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> rotateX(
-		tvec3<T, P> const & v,
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<3, T, P> rotateX(
+		vec<3, T, P> const & v,
 		T const & angle);
 
 	//! Rotate a three dimensional vector around the Y axis.
 	//! From GLM_GTX_rotate_vector extension.
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> rotateY(
-		tvec3<T, P> const & v,
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<3, T, P> rotateY(
+		vec<3, T, P> const & v,
 		T const & angle);
 		
 	//! Rotate a three dimensional vector around the Z axis.
 	//! From GLM_GTX_rotate_vector extension.
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> rotateZ(
-		tvec3<T, P> const & v,
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<3, T, P> rotateZ(
+		vec<3, T, P> const & v,
 		T const & angle);
 		
 	//! Rotate a four dimentionnals vector around the X axis.
 	//! From GLM_GTX_rotate_vector extension.
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec4<T, P> rotateX(
-		tvec4<T, P> const & v,
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<4, T, P> rotateX(
+		vec<4, T, P> const & v,
 		T const & angle);
 		
 	//! Rotate a four dimensional vector around the X axis.
 	//! From GLM_GTX_rotate_vector extension.
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec4<T, P> rotateY(
-		tvec4<T, P> const & v,
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<4, T, P> rotateY(
+		vec<4, T, P> const & v,
 		T const & angle);
 		
 	//! Rotate a four dimensional vector around the X axis.
 	//! From GLM_GTX_rotate_vector extension.
-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec4<T, P> rotateZ(
-		tvec4<T, P> const & v,
+	template<typename T, precision P>
+	GLM_FUNC_DECL vec<4, T, P> rotateZ(
+		vec<4, T, P> const & v,
 		T const & angle);
 		
 	//! Build a rotation matrix from a normal and a up vector.
 	//! From GLM_GTX_rotate_vector extension.
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat4x4<T, P> orientation(
-		tvec3<T, P> const & Normal,
-		tvec3<T, P> const & Up);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<4, 4, T, P> orientation(
+		vec<3, T, P> const & Normal,
+		vec<3, T, P> const & Up);
 
 	/// @}
 }//namespace glm
diff --git a/glm/gtx/rotate_vector.inl b/glm/gtx/rotate_vector.inl
index 5620e96c..7361c37d 100644
--- a/glm/gtx/rotate_vector.inl
+++ b/glm/gtx/rotate_vector.inl
@@ -3,11 +3,11 @@
 
 namespace glm
 {
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> slerp
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> slerp
 	(
-		tvec3<T, P> const & x,
-		tvec3<T, P> const & y,
+		vec<3, T, P> const & x,
+		vec<3, T, P> const & y,
 		T const & a
 	)
 	{
@@ -25,14 +25,14 @@ namespace glm
 		return x * t1 + y * t2;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P> rotate
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<2, T, P> rotate
 	(
-		tvec2<T, P> const & v,
+		vec<2, T, P> const & v,
 		T const & angle
 	)
 	{
-		tvec2<T, P> Result;
+		vec<2, T, P> Result;
 		T const Cos(cos(angle));
 		T const Sin(sin(angle));
 
@@ -41,47 +41,47 @@ namespace glm
 		return Result;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> rotate
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> rotate
 	(
-		tvec3<T, P> const & v,
+		vec<3, T, P> const & v,
 		T const & angle,
-		tvec3<T, P> const & normal
+		vec<3, T, P> const & normal
 	)
 	{
-		return tmat3x3<T, P>(glm::rotate(angle, normal)) * v;
+		return mat<3, 3, T, P>(glm::rotate(angle, normal)) * v;
 	}
 	/*
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> rotateGTX(
-		const tvec3<T, P>& x,
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> rotateGTX(
+		const vec<3, T, P>& x,
 		T angle,
-		const tvec3<T, P>& normal)
+		const vec<3, T, P>& normal)
 	{
 		const T Cos = cos(radians(angle));
 		const T Sin = sin(radians(angle));
 		return x * Cos + ((x * normal) * (T(1) - Cos)) * normal + cross(x, normal) * Sin;
 	}
 	*/
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> rotate
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, T, P> rotate
 	(
-		tvec4<T, P> const & v,
+		vec<4, T, P> const & v,
 		T const & angle,
-		tvec3<T, P> const & normal
+		vec<3, T, P> const & normal
 	)
 	{
 		return rotate(angle, normal) * v;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> rotateX
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> rotateX
 	(
-		tvec3<T, P> const & v,
+		vec<3, T, P> const & v,
 		T const & angle
 	)
 	{
-		tvec3<T, P> Result(v);
+		vec<3, T, P> Result(v);
 		T const Cos(cos(angle));
 		T const Sin(sin(angle));
 
@@ -90,14 +90,14 @@ namespace glm
 		return Result;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> rotateY
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> rotateY
 	(
-		tvec3<T, P> const & v,
+		vec<3, T, P> const & v,
 		T const & angle
 	)
 	{
-		tvec3<T, P> Result = v;
+		vec<3, T, P> Result = v;
 		T const Cos(cos(angle));
 		T const Sin(sin(angle));
 
@@ -106,14 +106,14 @@ namespace glm
 		return Result;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> rotateZ
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, T, P> rotateZ
 	(
-		tvec3<T, P> const & v,
+		vec<3, T, P> const & v,
 		T const & angle
 	)
 	{
-		tvec3<T, P> Result = v;
+		vec<3, T, P> Result = v;
 		T const Cos(cos(angle));
 		T const Sin(sin(angle));
 
@@ -122,14 +122,14 @@ namespace glm
 		return Result;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> rotateX
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, T, P> rotateX
 	(
-		tvec4<T, P> const & v,
+		vec<4, T, P> const & v,
 		T const & angle
 	)
 	{
-		tvec4<T, P> Result = v;
+		vec<4, T, P> Result = v;
 		T const Cos(cos(angle));
 		T const Sin(sin(angle));
 
@@ -138,14 +138,14 @@ namespace glm
 		return Result;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> rotateY
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, T, P> rotateY
 	(
-		tvec4<T, P> const & v,
+		vec<4, T, P> const & v,
 		T const & angle
 	)
 	{
-		tvec4<T, P> Result = v;
+		vec<4, T, P> Result = v;
 		T const Cos(cos(angle));
 		T const Sin(sin(angle));
 
@@ -154,14 +154,14 @@ namespace glm
 		return Result;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> rotateZ
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, T, P> rotateZ
 	(
-		tvec4<T, P> const & v,
+		vec<4, T, P> const & v,
 		T const & angle
 	)
 	{
-		tvec4<T, P> Result = v;
+		vec<4, T, P> Result = v;
 		T const Cos(cos(angle));
 		T const Sin(sin(angle));
 
@@ -170,17 +170,17 @@ namespace glm
 		return Result;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> orientation
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, P> orientation
 	(
-		tvec3<T, P> const & Normal,
-		tvec3<T, P> const & Up
+		vec<3, T, P> const & Normal,
+		vec<3, T, P> const & Up
 	)
 	{
 		if(all(equal(Normal, Up)))
-			return tmat4x4<T, P>(T(1));
+			return mat<4, 4, T, P>(T(1));
 
-		tvec3<T, P> RotationAxis = cross(Up, Normal);
+		vec<3, T, P> RotationAxis = cross(Up, Normal);
 		T Angle = acos(dot(Normal, Up));
 
 		return rotate(Angle, RotationAxis);
diff --git a/glm/gtx/scalar_multiplication.hpp b/glm/gtx/scalar_multiplication.hpp
index 3992f464..568391c1 100644
--- a/glm/gtx/scalar_multiplication.hpp
+++ b/glm/gtx/scalar_multiplication.hpp
@@ -30,26 +30,26 @@
 
 namespace glm
 {
-	template <typename T, typename Vec>
+	template<typename T, typename Vec>
 	using return_type_scalar_multiplication = typename std::enable_if<
 		!std::is_same<T, float>::value       // T may not be a float
 		&& std::is_arithmetic<T>::value, Vec // But it may be an int or double (no vec3 or mat3, ...)
 	>::type;
 
 #define GLM_IMPLEMENT_SCAL_MULT(Vec) \
-	template <typename T> \
+	template<typename T> \
 	return_type_scalar_multiplication<T, Vec> \
 	operator*(T const & s, Vec rh){ \
 		return rh *= static_cast<float>(s); \
 	} \
 	 \
-	template <typename T> \
+	template<typename T> \
 	return_type_scalar_multiplication<T, Vec> \
 	operator*(Vec lh, T const & s){ \
 		return lh *= static_cast<float>(s); \
 	} \
 	 \
-	template <typename T> \
+	template<typename T> \
 	return_type_scalar_multiplication<T, Vec> \
 	operator/(Vec lh, T const & s){ \
 		return lh *= 1.0f / s; \
diff --git a/glm/gtx/scalar_relational.inl b/glm/gtx/scalar_relational.inl
index 709da04c..ba9ec9d8 100644
--- a/glm/gtx/scalar_relational.inl
+++ b/glm/gtx/scalar_relational.inl
@@ -3,7 +3,7 @@
 
 namespace glm
 {
-	template <typename T>
+	template<typename T>
 	GLM_FUNC_QUALIFIER bool lessThan
 	(
 		T const & x, 
@@ -13,7 +13,7 @@ namespace glm
 		return x < y;
 	}
 
-	template <typename T>
+	template<typename T>
 	GLM_FUNC_QUALIFIER bool lessThanEqual
 	(
 		T const & x, 
@@ -23,7 +23,7 @@ namespace glm
 		return x <= y;
 	}
 
-	template <typename T>
+	template<typename T>
 	GLM_FUNC_QUALIFIER bool greaterThan
 	(
 		T const & x, 
@@ -33,7 +33,7 @@ namespace glm
 		return x > y;
 	}
 
-	template <typename T>
+	template<typename T>
 	GLM_FUNC_QUALIFIER bool greaterThanEqual
 	(
 		T const & x, 
@@ -43,7 +43,7 @@ namespace glm
 		return x >= y;
 	}
 
-	template <typename T>
+	template<typename T>
 	GLM_FUNC_QUALIFIER bool equal
 	(
 		T const & x, 
@@ -53,7 +53,7 @@ namespace glm
 		return x == y;
 	}
 
-	template <typename T>
+	template<typename T>
 	GLM_FUNC_QUALIFIER bool notEqual
 	(
 		T const & x, 
diff --git a/glm/gtx/spline.hpp b/glm/gtx/spline.hpp
index 3c77cc3e..28fb7738 100644
--- a/glm/gtx/spline.hpp
+++ b/glm/gtx/spline.hpp
@@ -31,7 +31,7 @@ namespace glm
 
 	/// Return a point from a catmull rom curve.
 	/// @see gtx_spline extension.
-	template <typename genType> 
+	template<typename genType> 
 	GLM_FUNC_DECL genType catmullRom(
 		genType const & v1, 
 		genType const & v2, 
@@ -41,7 +41,7 @@ namespace glm
 		
 	/// Return a point from a hermite curve.
 	/// @see gtx_spline extension.
-	template <typename genType> 
+	template<typename genType> 
 	GLM_FUNC_DECL genType hermite(
 		genType const & v1, 
 		genType const & t1, 
@@ -51,7 +51,7 @@ namespace glm
 		
 	/// Return a point from a cubic curve. 
 	/// @see gtx_spline extension.
-	template <typename genType> 
+	template<typename genType> 
 	GLM_FUNC_DECL genType cubic(
 		genType const & v1, 
 		genType const & v2, 
diff --git a/glm/gtx/spline.inl b/glm/gtx/spline.inl
index fcd33828..21269a8e 100644
--- a/glm/gtx/spline.inl
+++ b/glm/gtx/spline.inl
@@ -3,7 +3,7 @@
 
 namespace glm
 {
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER genType catmullRom
 	(
 		genType const & v1, 
@@ -26,7 +26,7 @@ namespace glm
 
 	}
 
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER genType hermite
 	(
 		genType const & v1, 
@@ -48,7 +48,7 @@ namespace glm
 		return f1 * v1 + f2 * v2 + f3 * t1 + f4 * t2;
 	}
 
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER genType cubic
 	(
 		genType const & v1, 
diff --git a/glm/gtx/std_based_type.hpp b/glm/gtx/std_based_type.hpp
index 5b45335e..70530bbe 100644
--- a/glm/gtx/std_based_type.hpp
+++ b/glm/gtx/std_based_type.hpp
@@ -31,35 +31,35 @@ namespace glm
 
 	/// Vector type based of one std::size_t component.
 	/// @see GLM_GTX_std_based_type
-	typedef tvec1<std::size_t, defaultp>		size1;
+	typedef vec<1, std::size_t, defaultp>		size1;
 
 	/// Vector type based of two std::size_t components.
 	/// @see GLM_GTX_std_based_type
-	typedef tvec2<std::size_t, defaultp>		size2;
+	typedef vec<2, std::size_t, defaultp>		size2;
 
 	/// Vector type based of three std::size_t components.
 	/// @see GLM_GTX_std_based_type
-	typedef tvec3<std::size_t, defaultp>		size3;
+	typedef vec<3, std::size_t, defaultp>		size3;
 
 	/// Vector type based of four std::size_t components.
 	/// @see GLM_GTX_std_based_type
-	typedef tvec4<std::size_t, defaultp>		size4;
+	typedef vec<4, std::size_t, defaultp>		size4;
 
 	/// Vector type based of one std::size_t component.
 	/// @see GLM_GTX_std_based_type
-	typedef tvec1<std::size_t, defaultp>		size1_t;
+	typedef vec<1, std::size_t, defaultp>		size1_t;
 
 	/// Vector type based of two std::size_t components.
 	/// @see GLM_GTX_std_based_type
-	typedef tvec2<std::size_t, defaultp>		size2_t;
+	typedef vec<2, std::size_t, defaultp>		size2_t;
 
 	/// Vector type based of three std::size_t components.
 	/// @see GLM_GTX_std_based_type
-	typedef tvec3<std::size_t, defaultp>		size3_t;
+	typedef vec<3, std::size_t, defaultp>		size3_t;
 
 	/// Vector type based of four std::size_t components.
 	/// @see GLM_GTX_std_based_type
-	typedef tvec4<std::size_t, defaultp>		size4_t;
+	typedef vec<4, std::size_t, defaultp>		size4_t;
 
 	/// @}
 }//namespace glm
diff --git a/glm/gtx/string_cast.hpp b/glm/gtx/string_cast.hpp
index e7778d7c..41f8cc7a 100644
--- a/glm/gtx/string_cast.hpp
+++ b/glm/gtx/string_cast.hpp
@@ -21,6 +21,7 @@
 #include "../gtc/quaternion.hpp"
 #include "../gtx/dual_quaternion.hpp"
 #include <string>
+#include <cmath>
 
 #ifndef GLM_ENABLE_EXPERIMENTAL
 #	error "GLM: GLM_GTX_string_cast is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it."
@@ -41,8 +42,8 @@ namespace glm
 
 	/// Create a string from a GLM vector or matrix typed variable.
 	/// @see gtx_string_cast extension.
-	template <template <typename, precision> class matType, typename T, precision P>
-	GLM_FUNC_DECL std::string to_string(matType<T, P> const & x);
+	template<typename genType>
+	GLM_FUNC_DECL std::string to_string(genType const& x);
 
 	/// @}
 }//namespace glm
diff --git a/glm/gtx/string_cast.inl b/glm/gtx/string_cast.inl
index 19f136b7..0bf73a54 100644
--- a/glm/gtx/string_cast.inl
+++ b/glm/gtx/string_cast.inl
@@ -30,119 +30,119 @@ namespace detail
 	static const char* LabelTrue = "true";
 	static const char* LabelFalse = "false";
 
-	template <typename T, bool isFloat = false>
+	template<typename T, bool isFloat = false>
 	struct literal
 	{
 		GLM_FUNC_QUALIFIER static char const * value() {return "%d";};
 	};
 
-	template <typename T>
+	template<typename T>
 	struct literal<T, true>
 	{
 		GLM_FUNC_QUALIFIER static char const * value() {return "%f";};
 	};
 
 #	if GLM_MODEL == GLM_MODEL_32 && GLM_COMPILER && GLM_COMPILER_VC
-	template <>
+	template<>
 	struct literal<uint64_t, false>
 	{
 		GLM_FUNC_QUALIFIER static char const * value() {return "%lld";};
 	};
 
-	template <>
+	template<>
 	struct literal<int64_t, false>
 	{
 		GLM_FUNC_QUALIFIER static char const * value() {return "%lld";};
 	};
 #	endif//GLM_MODEL == GLM_MODEL_32 && GLM_COMPILER && GLM_COMPILER_VC
 
-	template <typename T>
+	template<typename T>
 	struct prefix{};
 
-	template <>
+	template<>
 	struct prefix<float>
 	{
 		GLM_FUNC_QUALIFIER static char const * value() {return "";};
 	};
 
-	template <>
+	template<>
 	struct prefix<double>
 	{
 		GLM_FUNC_QUALIFIER static char const * value() {return "d";};
 	};
 
-	template <>
+	template<>
 	struct prefix<bool>
 	{
 		GLM_FUNC_QUALIFIER static char const * value() {return "b";};
 	};
 
-	template <>
+	template<>
 	struct prefix<uint8_t>
 	{
 		GLM_FUNC_QUALIFIER static char const * value() {return "u8";};
 	};
 
-	template <>
+	template<>
 	struct prefix<int8_t>
 	{
 		GLM_FUNC_QUALIFIER static char const * value() {return "i8";};
 	};
 
-	template <>
+	template<>
 	struct prefix<uint16_t>
 	{
 		GLM_FUNC_QUALIFIER static char const * value() {return "u16";};
 	};
 
-	template <>
+	template<>
 	struct prefix<int16_t>
 	{
 		GLM_FUNC_QUALIFIER static char const * value() {return "i16";};
 	};
 
-	template <>
+	template<>
 	struct prefix<uint32_t>
 	{
 		GLM_FUNC_QUALIFIER static char const * value() {return "u";};
 	};
 
-	template <>
+	template<>
 	struct prefix<int32_t>
 	{
 		GLM_FUNC_QUALIFIER static char const * value() {return "i";};
 	};
 
-	template <>
+	template<>
 	struct prefix<uint64_t>
 	{
 		GLM_FUNC_QUALIFIER static char const * value() {return "u64";};
 	};
 
-	template <>
+	template<>
 	struct prefix<int64_t>
 	{
 		GLM_FUNC_QUALIFIER static char const * value() {return "i64";};
 	};
 
-	template <template <typename, precision> class matType, typename T, precision P>
+	template<typename matType>
 	struct compute_to_string
 	{};
 
-	template <precision P>
-	struct compute_to_string<tvec1, bool, P>
+	template<precision P>
+	struct compute_to_string<vec<1, bool, P> >
 	{
-		GLM_FUNC_QUALIFIER static std::string call(tvec1<bool, P> const & x)
+		GLM_FUNC_QUALIFIER static std::string call(vec<1, bool, P> const & x)
 		{
 			return detail::format("bvec1(%s)",
 				x[0] ? detail::LabelTrue : detail::LabelFalse);
 		}
 	};
 
-	template <precision P>
-	struct compute_to_string<tvec2, bool, P>
+	template<precision P>
+	struct compute_to_string<vec<2, bool, P> >
 	{
-		GLM_FUNC_QUALIFIER static std::string call(tvec2<bool, P> const & x)
+		GLM_FUNC_QUALIFIER static std::string call(vec<2, bool, P> const & x)
 		{
 			return detail::format("bvec2(%s, %s)",
 				x[0] ? detail::LabelTrue : detail::LabelFalse,
@@ -150,10 +150,10 @@ namespace detail
 		}
 	};
 
-	template <precision P>
-	struct compute_to_string<tvec3, bool, P>
+	template<precision P>
+	struct compute_to_string<vec<3, bool, P> >
 	{
-		GLM_FUNC_QUALIFIER static std::string call(tvec3<bool, P> const & x)
+		GLM_FUNC_QUALIFIER static std::string call(vec<3, bool, P> const & x)
 		{
 			return detail::format("bvec3(%s, %s, %s)",
 				x[0] ? detail::LabelTrue : detail::LabelFalse,
@@ -162,10 +162,10 @@ namespace detail
 		}
 	};
 
-	template <precision P>
-	struct compute_to_string<tvec4, bool, P>
+	template<precision P>
+	struct compute_to_string<vec<4, bool, P> >
 	{
-		GLM_FUNC_QUALIFIER static std::string call(tvec4<bool, P> const & x)
+		GLM_FUNC_QUALIFIER static std::string call(vec<4, bool, P> const & x)
 		{
 			return detail::format("bvec4(%s, %s, %s, %s)",
 				x[0] ? detail::LabelTrue : detail::LabelFalse,
@@ -175,10 +175,10 @@ namespace detail
 		}
 	};
 
-	template <typename T, precision P>
-	struct compute_to_string<tvec1, T, P>
+	template<typename T, precision P>
+	struct compute_to_string<vec<1, T, P> >
 	{
-		GLM_FUNC_QUALIFIER static std::string call(tvec1<T, P> const & x)
+		GLM_FUNC_QUALIFIER static std::string call(vec<1, T, P> const & x)
 		{
 			char const * PrefixStr = prefix<T>::value();
 			char const * LiteralStr = literal<T, std::numeric_limits<T>::is_iec559>::value();
@@ -190,10 +190,10 @@ namespace detail
 		}
 	};
 
-	template <typename T, precision P>
-	struct compute_to_string<tvec2, T, P>
+	template<typename T, precision P>
+	struct compute_to_string<vec<2, T, P> >
 	{
-		GLM_FUNC_QUALIFIER static std::string call(tvec2<T, P> const & x)
+		GLM_FUNC_QUALIFIER static std::string call(vec<2, T, P> const & x)
 		{
 			char const * PrefixStr = prefix<T>::value();
 			char const * LiteralStr = literal<T, std::numeric_limits<T>::is_iec559>::value();
@@ -205,10 +205,10 @@ namespace detail
 		}
 	};
 
-	template <typename T, precision P>
-	struct compute_to_string<tvec3, T, P>
+	template<typename T, precision P>
+	struct compute_to_string<vec<3, T, P> >
 	{
-		GLM_FUNC_QUALIFIER static std::string call(tvec3<T, P> const & x)
+		GLM_FUNC_QUALIFIER static std::string call(vec<3, T, P> const & x)
 		{
 			char const * PrefixStr = prefix<T>::value();
 			char const * LiteralStr = literal<T, std::numeric_limits<T>::is_iec559>::value();
@@ -220,10 +220,10 @@ namespace detail
 		}
 	};
 
-	template <typename T, precision P>
-	struct compute_to_string<tvec4, T, P>
+	template<typename T, precision P>
+	struct compute_to_string<vec<4, T, P> >
 	{
-		GLM_FUNC_QUALIFIER static std::string call(tvec4<T, P> const & x)
+		GLM_FUNC_QUALIFIER static std::string call(vec<4, T, P> const & x)
 		{
 			char const * PrefixStr = prefix<T>::value();
 			char const * LiteralStr = literal<T, std::numeric_limits<T>::is_iec559>::value();
@@ -236,10 +236,10 @@ namespace detail
 	};
 
 
-	template <typename T, precision P>
-	struct compute_to_string<tmat2x2, T, P>
+	template<typename T, precision P>
+	struct compute_to_string<mat<2, 2, T, P> >
 	{
-		GLM_FUNC_QUALIFIER static std::string call(tmat2x2<T, P> const & x)
+		GLM_FUNC_QUALIFIER static std::string call(mat<2, 2, T, P> const & x)
 		{
 			char const * PrefixStr = prefix<T>::value();
 			char const * LiteralStr = literal<T, std::numeric_limits<T>::is_iec559>::value();
@@ -254,10 +254,10 @@ namespace detail
 		}
 	};
 
-	template <typename T, precision P>
-	struct compute_to_string<tmat2x3, T, P>
+	template<typename T, precision P>
+	struct compute_to_string<mat<2, 3, T, P> >
 	{
-		GLM_FUNC_QUALIFIER static std::string call(tmat2x3<T, P> const & x)
+		GLM_FUNC_QUALIFIER static std::string call(mat<2, 3, T, P> const & x)
 		{
 			char const * PrefixStr = prefix<T>::value();
 			char const * LiteralStr = literal<T, std::numeric_limits<T>::is_iec559>::value();
@@ -272,10 +272,10 @@ namespace detail
 		}
 	};
 
-	template <typename T, precision P>
-	struct compute_to_string<tmat2x4, T, P>
+	template<typename T, precision P>
+	struct compute_to_string<mat<2, 4, T, P> >
 	{
-		GLM_FUNC_QUALIFIER static std::string call(tmat2x4<T, P> const & x)
+		GLM_FUNC_QUALIFIER static std::string call(mat<2, 4, T, P> const & x)
 		{
 			char const * PrefixStr = prefix<T>::value();
 			char const * LiteralStr = literal<T, std::numeric_limits<T>::is_iec559>::value();
@@ -290,10 +290,10 @@ namespace detail
 		}
 	};
 
-	template <typename T, precision P>
-	struct compute_to_string<tmat3x2, T, P>
+	template<typename T, precision P>
+	struct compute_to_string<mat<3, 2, T, P> >
 	{
-		GLM_FUNC_QUALIFIER static std::string call(tmat3x2<T, P> const & x)
+		GLM_FUNC_QUALIFIER static std::string call(mat<3, 2, T, P> const & x)
 		{
 			char const * PrefixStr = prefix<T>::value();
 			char const * LiteralStr = literal<T, std::numeric_limits<T>::is_iec559>::value();
@@ -310,10 +310,10 @@ namespace detail
 		}
 	};
 
-	template <typename T, precision P>
-	struct compute_to_string<tmat3x3, T, P>
+	template<typename T, precision P>
+	struct compute_to_string<mat<3, 3, T, P> >
 	{
-		GLM_FUNC_QUALIFIER static std::string call(tmat3x3<T, P> const & x)
+		GLM_FUNC_QUALIFIER static std::string call(mat<3, 3, T, P> const & x)
 		{
 			char const * PrefixStr = prefix<T>::value();
 			char const * LiteralStr = literal<T, std::numeric_limits<T>::is_iec559>::value();
@@ -330,10 +330,10 @@ namespace detail
 		}
 	};
 
-	template <typename T, precision P>
-	struct compute_to_string<tmat3x4, T, P>
+	template<typename T, precision P>
+	struct compute_to_string<mat<3, 4, T, P> >
 	{
-		GLM_FUNC_QUALIFIER static std::string call(tmat3x4<T, P> const & x)
+		GLM_FUNC_QUALIFIER static std::string call(mat<3, 4, T, P> const & x)
 		{
 			char const * PrefixStr = prefix<T>::value();
 			char const * LiteralStr = literal<T, std::numeric_limits<T>::is_iec559>::value();
@@ -350,10 +350,10 @@ namespace detail
 		}
 	};
 
-	template <typename T, precision P>
-	struct compute_to_string<tmat4x2, T, P>
+	template<typename T, precision P>
+	struct compute_to_string<mat<4, 2, T, P> >
 	{
-		GLM_FUNC_QUALIFIER static std::string call(tmat4x2<T, P> const & x)
+		GLM_FUNC_QUALIFIER static std::string call(mat<4, 2, T, P> const & x)
 		{
 			char const * PrefixStr = prefix<T>::value();
 			char const * LiteralStr = literal<T, std::numeric_limits<T>::is_iec559>::value();
@@ -372,10 +372,10 @@ namespace detail
 		}
 	};
 
-	template <typename T, precision P>
-	struct compute_to_string<tmat4x3, T, P>
+	template<typename T, precision P>
+	struct compute_to_string<mat<4, 3, T, P> >
 	{
-		GLM_FUNC_QUALIFIER static std::string call(tmat4x3<T, P> const & x)
+		GLM_FUNC_QUALIFIER static std::string call(mat<4, 3, T, P> const & x)
 		{
 			char const * PrefixStr = prefix<T>::value();
 			char const * LiteralStr = literal<T, std::numeric_limits<T>::is_iec559>::value();
@@ -394,10 +394,10 @@ namespace detail
 		}
 	};
 
-	template <typename T, precision P>
-	struct compute_to_string<tmat4x4, T, P>
+	template<typename T, precision P>
+	struct compute_to_string<mat<4, 4, T, P> >
 	{
-		GLM_FUNC_QUALIFIER static std::string call(tmat4x4<T, P> const & x)
+		GLM_FUNC_QUALIFIER static std::string call(mat<4, 4, T, P> const & x)
 		{
 			char const * PrefixStr = prefix<T>::value();
 			char const * LiteralStr = literal<T, std::numeric_limits<T>::is_iec559>::value();
@@ -417,8 +417,8 @@ namespace detail
 	};
 
 
-	template <typename T, precision P>
-	struct compute_to_string<tquat, T, P>
+	template<typename T, precision P>
+	struct compute_to_string<tquat<T, P> >
 	{
 		GLM_FUNC_QUALIFIER static std::string call(tquat<T, P> const & x)
 		{
@@ -432,8 +432,8 @@ namespace detail
 		}
 	};
 
-	template <typename T, precision P>
-	struct compute_to_string<tdualquat, T, P>
+	template<typename T, precision P>
+	struct compute_to_string<tdualquat<T, P> >
 	{
 		GLM_FUNC_QUALIFIER static std::string call(tdualquat<T, P> const & x)
 		{
@@ -449,10 +449,10 @@ namespace detail
 
 }//namespace detail
 
-template <template <typename, precision> class matType, typename T, precision P>
-GLM_FUNC_QUALIFIER std::string to_string(matType<T, P> const & x)
+template<class matType>
+GLM_FUNC_QUALIFIER std::string to_string(matType const& x)
 {
-	return detail::compute_to_string<matType, T, P>::call(x);
+	return detail::compute_to_string<matType>::call(x);
 }
 
 }//namespace glm
diff --git a/glm/gtx/transform.hpp b/glm/gtx/transform.hpp
index f0fab19d..f6023c65 100644
--- a/glm/gtx/transform.hpp
+++ b/glm/gtx/transform.hpp
@@ -35,24 +35,24 @@ namespace glm
 	/// Transforms a matrix with a translation 4 * 4 matrix created from 3 scalars.
 	/// @see gtc_matrix_transform
 	/// @see gtx_transform
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat4x4<T, P> translate(
-		tvec3<T, P> const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<4, 4, T, P> translate(
+		vec<3, T, P> const & v);
 
 	/// Builds a rotation 4 * 4 matrix created from an axis of 3 scalars and an angle expressed in radians. 
 	/// @see gtc_matrix_transform
 	/// @see gtx_transform
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat4x4<T, P> rotate(
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<4, 4, T, P> rotate(
 		T angle, 
-		tvec3<T, P> const & v);
+		vec<3, T, P> const & v);
 
 	/// Transforms a matrix with a scale 4 * 4 matrix created from a vector of 3 components.
 	/// @see gtc_matrix_transform
 	/// @see gtx_transform
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat4x4<T, P> scale(
-		tvec3<T, P> const & v);
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<4, 4, T, P> scale(
+		vec<3, T, P> const & v);
 
 	/// @}
 }// namespace glm
diff --git a/glm/gtx/transform.inl b/glm/gtx/transform.inl
index 516d8661..bd855049 100644
--- a/glm/gtx/transform.inl
+++ b/glm/gtx/transform.inl
@@ -3,22 +3,22 @@
 
 namespace glm
 {
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> translate(tvec3<T, P> const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, P> translate(vec<3, T, P> const & v)
 	{
-		return translate(tmat4x4<T, P>(static_cast<T>(1)), v);
+		return translate(mat<4, 4, T, P>(static_cast<T>(1)), v);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> rotate(T angle, tvec3<T, P> const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, P> rotate(T angle, vec<3, T, P> const & v)
 	{
-		return rotate(tmat4x4<T, P>(static_cast<T>(1)), angle, v);
+		return rotate(mat<4, 4, T, P>(static_cast<T>(1)), angle, v);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> scale(tvec3<T, P> const & v)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, P> scale(vec<3, T, P> const & v)
 	{
-		return scale(tmat4x4<T, P>(static_cast<T>(1)), v);
+		return scale(mat<4, 4, T, P>(static_cast<T>(1)), v);
 	}
 
 }//namespace glm
diff --git a/glm/gtx/transform2.hpp b/glm/gtx/transform2.hpp
index 6a9b5c2f..957bd3a8 100644
--- a/glm/gtx/transform2.hpp
+++ b/glm/gtx/transform2.hpp
@@ -32,76 +32,76 @@ namespace glm
 
 	//! Transforms a matrix with a shearing on X axis.
 	//! From GLM_GTX_transform2 extension.
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat3x3<T, P> shearX2D(
-		tmat3x3<T, P> const & m, 
+	template<typename T, precision P>
+	GLM_FUNC_DECL mat<3, 3, T, P> shearX2D(
+		mat<3, 3, T, P> const& m, 
 		T y);
 
 	//! Transforms a matrix with a shearing on Y axis.
 	//! From GLM_GTX_transform2 extension.
-	template <typename T, precision P> 
-	GLM_FUNC_DECL tmat3x3<T, P> shearY2D(
-		tmat3x3<T, P> const & m, 
+	template<typename T, precision P> 
+	GLM_FUNC_DECL mat<3, 3, T, P> shearY2D(
+		mat<3, 3, T, P> const& m, 
 		T x);
 
 	//! Transforms a matrix with a shearing on X axis
 	//! From GLM_GTX_transform2 extension.
-	template <typename T, precision P> 
-	GLM_FUNC_DECL tmat4x4<T, P> shearX3D(
-		const tmat4x4<T, P> & m,
+	template<typename T, precision P> 
+	GLM_FUNC_DECL mat<4, 4, T, P> shearX3D(
+		const mat<4, 4, T, P> & m,
 		T y, 
 		T z);
 
 	//! Transforms a matrix with a shearing on Y axis.
 	//! From GLM_GTX_transform2 extension.
-	template <typename T, precision P> 
-	GLM_FUNC_DECL tmat4x4<T, P> shearY3D(
-		const tmat4x4<T, P> & m, 
+	template<typename T, precision P> 
+	GLM_FUNC_DECL mat<4, 4, T, P> shearY3D(
+		const mat<4, 4, T, P> & m, 
 		T x, 
 		T z);
 
 	//! Transforms a matrix with a shearing on Z axis. 
 	//! From GLM_GTX_transform2 extension.
-	template <typename T, precision P> 
-	GLM_FUNC_DECL tmat4x4<T, P> shearZ3D(
-		const tmat4x4<T, P> & m, 
+	template<typename T, precision P> 
+	GLM_FUNC_DECL mat<4, 4, T, P> shearZ3D(
+		const mat<4, 4, T, P> & m, 
 		T x, 
 		T y);
 
-	//template <typename T> GLM_FUNC_QUALIFIER tmat4x4<T, P> shear(const tmat4x4<T, P> & m, shearPlane, planePoint, angle)
+	//template<typename T> GLM_FUNC_QUALIFIER mat<4, 4, T, P> shear(const mat<4, 4, T, P> & m, shearPlane, planePoint, angle)
 	// Identity + tan(angle) * cross(Normal, OnPlaneVector)     0
 	// - dot(PointOnPlane, normal) * OnPlaneVector              1
 
 	// Reflect functions seem to don't work
-	//template <typename T> tmat3x3<T, P> reflect2D(const tmat3x3<T, P> & m, const tvec3<T, P>& normal){return reflect2DGTX(m, normal);}									//!< \brief Build a reflection matrix (from GLM_GTX_transform2 extension)
-	//template <typename T> tmat4x4<T, P> reflect3D(const tmat4x4<T, P> & m, const tvec3<T, P>& normal){return reflect3DGTX(m, normal);}									//!< \brief Build a reflection matrix (from GLM_GTX_transform2 extension)
+	//template<typename T> mat<3, 3, T, P> reflect2D(const mat<3, 3, T, P> & m, const vec<3, T, P>& normal){return reflect2DGTX(m, normal);}									//!< \brief Build a reflection matrix (from GLM_GTX_transform2 extension)
+	//template<typename T> mat<4, 4, T, P> reflect3D(const mat<4, 4, T, P> & m, const vec<3, T, P>& normal){return reflect3DGTX(m, normal);}									//!< \brief Build a reflection matrix (from GLM_GTX_transform2 extension)
 		
 	//! Build planar projection matrix along normal axis.
 	//! From GLM_GTX_transform2 extension.
-	template <typename T, precision P> 
-	GLM_FUNC_DECL tmat3x3<T, P> proj2D(
-		const tmat3x3<T, P> & m, 
-		const tvec3<T, P>& normal);
+	template<typename T, precision P> 
+	GLM_FUNC_DECL mat<3, 3, T, P> proj2D(
+		const mat<3, 3, T, P> & m, 
+		const vec<3, T, P>& normal);
 
 	//! Build planar projection matrix along normal axis.
 	//! From GLM_GTX_transform2 extension.
-	template <typename T, precision P> 
-	GLM_FUNC_DECL tmat4x4<T, P> proj3D(
-		const tmat4x4<T, P> & m, 
-		const tvec3<T, P>& normal);
+	template<typename T, precision P> 
+	GLM_FUNC_DECL mat<4, 4, T, P> proj3D(
+		const mat<4, 4, T, P> & m, 
+		const vec<3, T, P>& normal);
 
 	//! Build a scale bias matrix. 
 	//! From GLM_GTX_transform2 extension.
-	template <typename valType, precision P> 
-	GLM_FUNC_DECL tmat4x4<valType, P> scaleBias(
+	template<typename valType, precision P> 
+	GLM_FUNC_DECL mat<4, 4, valType, P> scaleBias(
 		valType scale, 
 		valType bias);
 
 	//! Build a scale bias matrix.
 	//! From GLM_GTX_transform2 extension.
-	template <typename valType, precision P> 
-	GLM_FUNC_DECL tmat4x4<valType, P> scaleBias(
-		tmat4x4<valType, P> const & m, 
+	template<typename valType, precision P> 
+	GLM_FUNC_DECL mat<4, 4, valType, P> scaleBias(
+		mat<4, 4, valType, P> const & m, 
 		valType scale, 
 		valType bias);
 
diff --git a/glm/gtx/transform2.inl b/glm/gtx/transform2.inl
index 6e0ab310..557e93cd 100644
--- a/glm/gtx/transform2.inl
+++ b/glm/gtx/transform2.inl
@@ -3,53 +3,53 @@
 
 namespace glm
 {
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x3<T, P> shearX2D(tmat3x3<T, P> const& m, T s)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, P> shearX2D(mat<3, 3, T, P> const& m, T s)
 	{
-		tmat3x3<T, P> r(1);
+		mat<3, 3, T, P> r(1);
 		r[1][0] = s;
 		return m * r;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x3<T, P> shearY2D(tmat3x3<T, P> const& m, T s)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, P> shearY2D(mat<3, 3, T, P> const& m, T s)
 	{
-		tmat3x3<T, P> r(1);
+		mat<3, 3, T, P> r(1);
 		r[0][1] = s;
 		return m * r;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> shearX3D(tmat4x4<T, P> const& m, T s, T t)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, P> shearX3D(mat<4, 4, T, P> const& m, T s, T t)
 	{
-		tmat4x4<T, P> r(1);
+		mat<4, 4, T, P> r(1);
 		r[0][1] = s;
 		r[0][2] = t;
 		return m * r;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> shearY3D(tmat4x4<T, P> const& m, T s, T t)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, P> shearY3D(mat<4, 4, T, P> const& m, T s, T t)
 	{
-		tmat4x4<T, P> r(1);
+		mat<4, 4, T, P> r(1);
 		r[1][0] = s;
 		r[1][2] = t;
 		return m * r;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> shearZ3D(tmat4x4<T, P> const& m, T s, T t)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, P> shearZ3D(mat<4, 4, T, P> const& m, T s, T t)
 	{
-		tmat4x4<T, P> r(1);
+		mat<4, 4, T, P> r(1);
 		r[2][0] = s;
 		r[2][1] = t;
 		return m * r;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x3<T, P> reflect2D(tmat3x3<T, P> const& m, tvec3<T, P> const& normal)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, P> reflect2D(mat<3, 3, T, P> const& m, vec<3, T, P> const& normal)
 	{
-		tmat3x3<T, P> r(static_cast<T>(1));
+		mat<3, 3, T, P> r(static_cast<T>(1));
 		r[0][0] = static_cast<T>(1) - static_cast<T>(2) * normal.x * normal.x;
 		r[0][1] = -static_cast<T>(2) * normal.x * normal.y;
 		r[1][0] = -static_cast<T>(2) * normal.x * normal.y;
@@ -57,10 +57,10 @@ namespace glm
 		return m * r;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> reflect3D(tmat4x4<T, P> const& m, tvec3<T, P> const& normal)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, P> reflect3D(mat<4, 4, T, P> const& m, vec<3, T, P> const& normal)
 	{
-		tmat4x4<T, P> r(static_cast<T>(1));
+		mat<4, 4, T, P> r(static_cast<T>(1));
 		r[0][0] = static_cast<T>(1) - static_cast<T>(2) * normal.x * normal.x;
 		r[0][1] = -static_cast<T>(2) * normal.x * normal.y;
 		r[0][2] = -static_cast<T>(2) * normal.x * normal.z;
@@ -75,12 +75,12 @@ namespace glm
 		return m * r;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x3<T, P> proj2D(
-		const tmat3x3<T, P>& m, 
-		const tvec3<T, P>& normal)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<3, 3, T, P> proj2D(
+		const mat<3, 3, T, P>& m, 
+		const vec<3, T, P>& normal)
 	{
-		tmat3x3<T, P> r(static_cast<T>(1));
+		mat<3, 3, T, P> r(static_cast<T>(1));
 		r[0][0] = static_cast<T>(1) - normal.x * normal.x;
 		r[0][1] = - normal.x * normal.y;
 		r[1][0] = - normal.x * normal.y;
@@ -88,12 +88,12 @@ namespace glm
 		return m * r;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> proj3D(
-		const tmat4x4<T, P>& m, 
-		const tvec3<T, P>& normal)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, P> proj3D(
+		const mat<4, 4, T, P>& m, 
+		const vec<3, T, P>& normal)
 	{
-		tmat4x4<T, P> r(static_cast<T>(1));
+		mat<4, 4, T, P> r(static_cast<T>(1));
 		r[0][0] = static_cast<T>(1) - normal.x * normal.x;
 		r[0][1] = - normal.x * normal.y;
 		r[0][2] = - normal.x * normal.z;
@@ -106,19 +106,19 @@ namespace glm
 		return m * r;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> scaleBias(T scale, T bias)
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, P> scaleBias(T scale, T bias)
 	{
-		tmat4x4<T, P> result;
-		result[3] = tvec4<T, P>(tvec3<T, P>(bias), static_cast<T>(1));
+		mat<4, 4, T, P> result;
+		result[3] = vec<4, T, P>(vec<3, T, P>(bias), static_cast<T>(1));
 		result[0][0] = scale;
 		result[1][1] = scale;
 		result[2][2] = scale;
 		return result;
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> scaleBias(tmat4x4<T, P> const& m, T scale, T bias)
+	template<typename T, precision P> 
+	GLM_FUNC_QUALIFIER mat<4, 4, T, P> scaleBias(mat<4, 4, T, P> const& m, T scale, T bias)
 	{
 		return m * scaleBias(scale, bias);
 	}
diff --git a/glm/gtx/type_trait.hpp b/glm/gtx/type_trait.hpp
index d4652573..4f0ba9b9 100644
--- a/glm/gtx/type_trait.hpp
+++ b/glm/gtx/type_trait.hpp
@@ -41,7 +41,7 @@ namespace glm
 	/// @addtogroup gtx_type_trait
 	/// @{
 
-	template <template <typename, precision> class genType, typename T, precision P>
+	template<typename T>
 	struct type
 	{
 		static bool const is_vec = false;
@@ -52,56 +52,20 @@ namespace glm
 		static length_t const rows = 0;
 	};
 
-	template <typename T, precision P>
-	struct type<tvec1, T, P>
+	template<length_t L, typename T, precision P>
+	struct type<vec<L, T, P> >
 	{
 		static bool const is_vec = true;
 		static bool const is_mat = false;
 		static bool const is_quat = false;
 		enum
 		{
-			components = 1
+			components = L
 		};
 	};
 
-	template <typename T, precision P>
-	struct type<tvec2, T, P>
-	{
-		static bool const is_vec = true;
-		static bool const is_mat = false;
-		static bool const is_quat = false;
-		enum
-		{
-			components = 2
-		};
-	};
-
-	template <typename T, precision P>
-	struct type<tvec3, T, P>
-	{
-		static bool const is_vec = true;
-		static bool const is_mat = false;
-		static bool const is_quat = false;
-		enum
-		{
-			components = 3
-		};
-	};
-
-	template <typename T, precision P>
-	struct type<tvec4, T, P>
-	{
-		static bool const is_vec = true;
-		static bool const is_mat = false;
-		static bool const is_quat = false;
-		enum
-		{
-			components = 4
-		};
-	};
-
-	template <typename T, precision P>
-	struct type<tmat2x2, T, P>
+	template<typename T, precision P>
+	struct type<mat<2, 2, T, P> >
 	{
 		static bool const is_vec = false;
 		static bool const is_mat = true;
@@ -114,8 +78,8 @@ namespace glm
 		};
 	};
 
-	template <typename T, precision P>
-	struct type<tmat2x3, T, P>
+	template<typename T, precision P>
+	struct type<mat<2, 3, T, P> >
 	{
 		static bool const is_vec = false;
 		static bool const is_mat = true;
@@ -128,8 +92,8 @@ namespace glm
 		};
 	};
 
-	template <typename T, precision P>
-	struct type<tmat2x4, T, P>
+	template<typename T, precision P>
+	struct type<mat<2, 4, T, P> >
 	{
 		static bool const is_vec = false;
 		static bool const is_mat = true;
@@ -142,8 +106,8 @@ namespace glm
 		};
 	};
 
-	template <typename T, precision P>
-	struct type<tmat3x2, T, P>
+	template<typename T, precision P>
+	struct type<mat<3, 2, T, P> >
 	{
 		static bool const is_vec = false;
 		static bool const is_mat = true;
@@ -156,8 +120,8 @@ namespace glm
 		};
 	};
 
-	template <typename T, precision P>
-	struct type<tmat3x3, T, P>
+	template<typename T, precision P>
+	struct type<mat<3, 3, T, P> >
 	{
 		static bool const is_vec = false;
 		static bool const is_mat = true;
@@ -170,8 +134,8 @@ namespace glm
 		};
 	};
 
-	template <typename T, precision P>
-	struct type<tmat3x4, T, P>
+	template<typename T, precision P>
+	struct type<mat<3, 4, T, P> >
 	{
 		static bool const is_vec = false;
 		static bool const is_mat = true;
@@ -184,8 +148,8 @@ namespace glm
 		};
 	};
 
-	template <typename T, precision P>
-	struct type<tmat4x2, T, P>
+	template<typename T, precision P>
+	struct type<mat<4, 2, T, P> >
 	{
 		static bool const is_vec = false;
 		static bool const is_mat = true;
@@ -198,8 +162,8 @@ namespace glm
 		};
 	};
 
-	template <typename T, precision P>
-	struct type<tmat4x3, T, P>
+	template<typename T, precision P>
+	struct type<mat<4, 3, T, P> >
 	{
 		static bool const is_vec = false;
 		static bool const is_mat = true;
@@ -212,8 +176,8 @@ namespace glm
 		};
 	};
 
-	template <typename T, precision P>
-	struct type<tmat4x4, T, P>
+	template<typename T, precision P>
+	struct type<mat<4, 4, T, P> >
 	{
 		static bool const is_vec = false;
 		static bool const is_mat = true;
@@ -226,8 +190,8 @@ namespace glm
 		};
 	};
 
-	template <typename T, precision P>
-	struct type<tquat, T, P>
+	template<typename T, precision P>
+	struct type<tquat<T, P> >
 	{
 		static bool const is_vec = false;
 		static bool const is_mat = false;
@@ -238,8 +202,8 @@ namespace glm
 		};
 	};
 
-	template <typename T, precision P>
-	struct type<tdualquat, T, P>
+	template<typename T, precision P>
+	struct type<tdualquat<T, P> >
 	{
 		static bool const is_vec = false;
 		static bool const is_mat = false;
diff --git a/glm/gtx/vec_swizzle.hpp b/glm/gtx/vec_swizzle.hpp
index 9e9c8195..c325d30c 100644
--- a/glm/gtx/vec_swizzle.hpp
+++ b/glm/gtx/vec_swizzle.hpp
@@ -21,2758 +21,2758 @@
 namespace glm {
 	// xx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec2<T, P> xx(const glm::tvec1<T, P> &v) {
-		return glm::tvec2<T, P>(v.x, v.x);
+	GLM_INLINE glm::vec<2, T, P> xx(const glm::vec<1, T, P> &v) {
+		return glm::vec<2, T, P>(v.x, v.x);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec2<T, P> xx(const glm::tvec2<T, P> &v) {
-		return glm::tvec2<T, P>(v.x, v.x);
+	GLM_INLINE glm::vec<2, T, P> xx(const glm::vec<2, T, P> &v) {
+		return glm::vec<2, T, P>(v.x, v.x);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec2<T, P> xx(const glm::tvec3<T, P> &v) {
-		return glm::tvec2<T, P>(v.x, v.x);
+	GLM_INLINE glm::vec<2, T, P> xx(const glm::vec<3, T, P> &v) {
+		return glm::vec<2, T, P>(v.x, v.x);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec2<T, P> xx(const glm::tvec4<T, P> &v) {
-		return glm::tvec2<T, P>(v.x, v.x);
+	GLM_INLINE glm::vec<2, T, P> xx(const glm::vec<4, T, P> &v) {
+		return glm::vec<2, T, P>(v.x, v.x);
 	}
 
 	// xy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec2<T, P> xy(const glm::tvec2<T, P> &v) {
-		return glm::tvec2<T, P>(v.x, v.y);
+	GLM_INLINE glm::vec<2, T, P> xy(const glm::vec<2, T, P> &v) {
+		return glm::vec<2, T, P>(v.x, v.y);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec2<T, P> xy(const glm::tvec3<T, P> &v) {
-		return glm::tvec2<T, P>(v.x, v.y);
+	GLM_INLINE glm::vec<2, T, P> xy(const glm::vec<3, T, P> &v) {
+		return glm::vec<2, T, P>(v.x, v.y);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec2<T, P> xy(const glm::tvec4<T, P> &v) {
-		return glm::tvec2<T, P>(v.x, v.y);
+	GLM_INLINE glm::vec<2, T, P> xy(const glm::vec<4, T, P> &v) {
+		return glm::vec<2, T, P>(v.x, v.y);
 	}
 
 	// xz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec2<T, P> xz(const glm::tvec3<T, P> &v) {
-		return glm::tvec2<T, P>(v.x, v.z);
+	GLM_INLINE glm::vec<2, T, P> xz(const glm::vec<3, T, P> &v) {
+		return glm::vec<2, T, P>(v.x, v.z);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec2<T, P> xz(const glm::tvec4<T, P> &v) {
-		return glm::tvec2<T, P>(v.x, v.z);
+	GLM_INLINE glm::vec<2, T, P> xz(const glm::vec<4, T, P> &v) {
+		return glm::vec<2, T, P>(v.x, v.z);
 	}
 
 	// xw
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec2<T, P> xw(const glm::tvec4<T, P> &v) {
-		return glm::tvec2<T, P>(v.x, v.w);
+	GLM_INLINE glm::vec<2, T, P> xw(const glm::vec<4, T, P> &v) {
+		return glm::vec<2, T, P>(v.x, v.w);
 	}
 
 	// yx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec2<T, P> yx(const glm::tvec2<T, P> &v) {
-		return glm::tvec2<T, P>(v.y, v.x);
+	GLM_INLINE glm::vec<2, T, P> yx(const glm::vec<2, T, P> &v) {
+		return glm::vec<2, T, P>(v.y, v.x);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec2<T, P> yx(const glm::tvec3<T, P> &v) {
-		return glm::tvec2<T, P>(v.y, v.x);
+	GLM_INLINE glm::vec<2, T, P> yx(const glm::vec<3, T, P> &v) {
+		return glm::vec<2, T, P>(v.y, v.x);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec2<T, P> yx(const glm::tvec4<T, P> &v) {
-		return glm::tvec2<T, P>(v.y, v.x);
+	GLM_INLINE glm::vec<2, T, P> yx(const glm::vec<4, T, P> &v) {
+		return glm::vec<2, T, P>(v.y, v.x);
 	}
 
 	// yy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec2<T, P> yy(const glm::tvec2<T, P> &v) {
-		return glm::tvec2<T, P>(v.y, v.y);
+	GLM_INLINE glm::vec<2, T, P> yy(const glm::vec<2, T, P> &v) {
+		return glm::vec<2, T, P>(v.y, v.y);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec2<T, P> yy(const glm::tvec3<T, P> &v) {
-		return glm::tvec2<T, P>(v.y, v.y);
+	GLM_INLINE glm::vec<2, T, P> yy(const glm::vec<3, T, P> &v) {
+		return glm::vec<2, T, P>(v.y, v.y);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec2<T, P> yy(const glm::tvec4<T, P> &v) {
-		return glm::tvec2<T, P>(v.y, v.y);
+	GLM_INLINE glm::vec<2, T, P> yy(const glm::vec<4, T, P> &v) {
+		return glm::vec<2, T, P>(v.y, v.y);
 	}
 
 	// yz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec2<T, P> yz(const glm::tvec3<T, P> &v) {
-		return glm::tvec2<T, P>(v.y, v.z);
+	GLM_INLINE glm::vec<2, T, P> yz(const glm::vec<3, T, P> &v) {
+		return glm::vec<2, T, P>(v.y, v.z);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec2<T, P> yz(const glm::tvec4<T, P> &v) {
-		return glm::tvec2<T, P>(v.y, v.z);
+	GLM_INLINE glm::vec<2, T, P> yz(const glm::vec<4, T, P> &v) {
+		return glm::vec<2, T, P>(v.y, v.z);
 	}
 
 	// yw
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec2<T, P> yw(const glm::tvec4<T, P> &v) {
-		return glm::tvec2<T, P>(v.y, v.w);
+	GLM_INLINE glm::vec<2, T, P> yw(const glm::vec<4, T, P> &v) {
+		return glm::vec<2, T, P>(v.y, v.w);
 	}
 
 	// zx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec2<T, P> zx(const glm::tvec3<T, P> &v) {
-		return glm::tvec2<T, P>(v.z, v.x);
+	GLM_INLINE glm::vec<2, T, P> zx(const glm::vec<3, T, P> &v) {
+		return glm::vec<2, T, P>(v.z, v.x);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec2<T, P> zx(const glm::tvec4<T, P> &v) {
-		return glm::tvec2<T, P>(v.z, v.x);
+	GLM_INLINE glm::vec<2, T, P> zx(const glm::vec<4, T, P> &v) {
+		return glm::vec<2, T, P>(v.z, v.x);
 	}
 
 	// zy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec2<T, P> zy(const glm::tvec3<T, P> &v) {
-		return glm::tvec2<T, P>(v.z, v.y);
+	GLM_INLINE glm::vec<2, T, P> zy(const glm::vec<3, T, P> &v) {
+		return glm::vec<2, T, P>(v.z, v.y);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec2<T, P> zy(const glm::tvec4<T, P> &v) {
-		return glm::tvec2<T, P>(v.z, v.y);
+	GLM_INLINE glm::vec<2, T, P> zy(const glm::vec<4, T, P> &v) {
+		return glm::vec<2, T, P>(v.z, v.y);
 	}
 
 	// zz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec2<T, P> zz(const glm::tvec3<T, P> &v) {
-		return glm::tvec2<T, P>(v.z, v.z);
+	GLM_INLINE glm::vec<2, T, P> zz(const glm::vec<3, T, P> &v) {
+		return glm::vec<2, T, P>(v.z, v.z);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec2<T, P> zz(const glm::tvec4<T, P> &v) {
-		return glm::tvec2<T, P>(v.z, v.z);
+	GLM_INLINE glm::vec<2, T, P> zz(const glm::vec<4, T, P> &v) {
+		return glm::vec<2, T, P>(v.z, v.z);
 	}
 
 	// zw
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec2<T, P> zw(const glm::tvec4<T, P> &v) {
-		return glm::tvec2<T, P>(v.z, v.w);
+	GLM_INLINE glm::vec<2, T, P> zw(const glm::vec<4, T, P> &v) {
+		return glm::vec<2, T, P>(v.z, v.w);
 	}
 
 	// wx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec2<T, P> wx(const glm::tvec4<T, P> &v) {
-		return glm::tvec2<T, P>(v.w, v.x);
+	GLM_INLINE glm::vec<2, T, P> wx(const glm::vec<4, T, P> &v) {
+		return glm::vec<2, T, P>(v.w, v.x);
 	}
 
 	// wy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec2<T, P> wy(const glm::tvec4<T, P> &v) {
-		return glm::tvec2<T, P>(v.w, v.y);
+	GLM_INLINE glm::vec<2, T, P> wy(const glm::vec<4, T, P> &v) {
+		return glm::vec<2, T, P>(v.w, v.y);
 	}
 
 	// wz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec2<T, P> wz(const glm::tvec4<T, P> &v) {
-		return glm::tvec2<T, P>(v.w, v.z);
+	GLM_INLINE glm::vec<2, T, P> wz(const glm::vec<4, T, P> &v) {
+		return glm::vec<2, T, P>(v.w, v.z);
 	}
 
 	// ww
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec2<T, P> ww(const glm::tvec4<T, P> &v) {
-		return glm::tvec2<T, P>(v.w, v.w);
+	GLM_INLINE glm::vec<2, T, P> ww(const glm::vec<4, T, P> &v) {
+		return glm::vec<2, T, P>(v.w, v.w);
 	}
 
 	// xxx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> xxx(const glm::tvec1<T, P> &v) {
-		return glm::tvec3<T, P>(v.x, v.x, v.x);
+	GLM_INLINE glm::vec<3, T, P> xxx(const glm::vec<1, T, P> &v) {
+		return glm::vec<3, T, P>(v.x, v.x, v.x);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> xxx(const glm::tvec2<T, P> &v) {
-		return glm::tvec3<T, P>(v.x, v.x, v.x);
+	GLM_INLINE glm::vec<3, T, P> xxx(const glm::vec<2, T, P> &v) {
+		return glm::vec<3, T, P>(v.x, v.x, v.x);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> xxx(const glm::tvec3<T, P> &v) {
-		return glm::tvec3<T, P>(v.x, v.x, v.x);
+	GLM_INLINE glm::vec<3, T, P> xxx(const glm::vec<3, T, P> &v) {
+		return glm::vec<3, T, P>(v.x, v.x, v.x);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> xxx(const glm::tvec4<T, P> &v) {
-		return glm::tvec3<T, P>(v.x, v.x, v.x);
+	GLM_INLINE glm::vec<3, T, P> xxx(const glm::vec<4, T, P> &v) {
+		return glm::vec<3, T, P>(v.x, v.x, v.x);
 	}
 
 	// xxy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> xxy(const glm::tvec2<T, P> &v) {
-		return glm::tvec3<T, P>(v.x, v.x, v.y);
+	GLM_INLINE glm::vec<3, T, P> xxy(const glm::vec<2, T, P> &v) {
+		return glm::vec<3, T, P>(v.x, v.x, v.y);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> xxy(const glm::tvec3<T, P> &v) {
-		return glm::tvec3<T, P>(v.x, v.x, v.y);
+	GLM_INLINE glm::vec<3, T, P> xxy(const glm::vec<3, T, P> &v) {
+		return glm::vec<3, T, P>(v.x, v.x, v.y);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> xxy(const glm::tvec4<T, P> &v) {
-		return glm::tvec3<T, P>(v.x, v.x, v.y);
+	GLM_INLINE glm::vec<3, T, P> xxy(const glm::vec<4, T, P> &v) {
+		return glm::vec<3, T, P>(v.x, v.x, v.y);
 	}
 
 	// xxz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> xxz(const glm::tvec3<T, P> &v) {
-		return glm::tvec3<T, P>(v.x, v.x, v.z);
+	GLM_INLINE glm::vec<3, T, P> xxz(const glm::vec<3, T, P> &v) {
+		return glm::vec<3, T, P>(v.x, v.x, v.z);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> xxz(const glm::tvec4<T, P> &v) {
-		return glm::tvec3<T, P>(v.x, v.x, v.z);
+	GLM_INLINE glm::vec<3, T, P> xxz(const glm::vec<4, T, P> &v) {
+		return glm::vec<3, T, P>(v.x, v.x, v.z);
 	}
 
 	// xxw
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> xxw(const glm::tvec4<T, P> &v) {
-		return glm::tvec3<T, P>(v.x, v.x, v.w);
+	GLM_INLINE glm::vec<3, T, P> xxw(const glm::vec<4, T, P> &v) {
+		return glm::vec<3, T, P>(v.x, v.x, v.w);
 	}
 
 	// xyx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> xyx(const glm::tvec2<T, P> &v) {
-		return glm::tvec3<T, P>(v.x, v.y, v.x);
+	GLM_INLINE glm::vec<3, T, P> xyx(const glm::vec<2, T, P> &v) {
+		return glm::vec<3, T, P>(v.x, v.y, v.x);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> xyx(const glm::tvec3<T, P> &v) {
-		return glm::tvec3<T, P>(v.x, v.y, v.x);
+	GLM_INLINE glm::vec<3, T, P> xyx(const glm::vec<3, T, P> &v) {
+		return glm::vec<3, T, P>(v.x, v.y, v.x);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> xyx(const glm::tvec4<T, P> &v) {
-		return glm::tvec3<T, P>(v.x, v.y, v.x);
+	GLM_INLINE glm::vec<3, T, P> xyx(const glm::vec<4, T, P> &v) {
+		return glm::vec<3, T, P>(v.x, v.y, v.x);
 	}
 
 	// xyy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> xyy(const glm::tvec2<T, P> &v) {
-		return glm::tvec3<T, P>(v.x, v.y, v.y);
+	GLM_INLINE glm::vec<3, T, P> xyy(const glm::vec<2, T, P> &v) {
+		return glm::vec<3, T, P>(v.x, v.y, v.y);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> xyy(const glm::tvec3<T, P> &v) {
-		return glm::tvec3<T, P>(v.x, v.y, v.y);
+	GLM_INLINE glm::vec<3, T, P> xyy(const glm::vec<3, T, P> &v) {
+		return glm::vec<3, T, P>(v.x, v.y, v.y);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> xyy(const glm::tvec4<T, P> &v) {
-		return glm::tvec3<T, P>(v.x, v.y, v.y);
+	GLM_INLINE glm::vec<3, T, P> xyy(const glm::vec<4, T, P> &v) {
+		return glm::vec<3, T, P>(v.x, v.y, v.y);
 	}
 
 	// xyz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> xyz(const glm::tvec3<T, P> &v) {
-		return glm::tvec3<T, P>(v.x, v.y, v.z);
+	GLM_INLINE glm::vec<3, T, P> xyz(const glm::vec<3, T, P> &v) {
+		return glm::vec<3, T, P>(v.x, v.y, v.z);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> xyz(const glm::tvec4<T, P> &v) {
-		return glm::tvec3<T, P>(v.x, v.y, v.z);
+	GLM_INLINE glm::vec<3, T, P> xyz(const glm::vec<4, T, P> &v) {
+		return glm::vec<3, T, P>(v.x, v.y, v.z);
 	}
 
 	// xyw
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> xyw(const glm::tvec4<T, P> &v) {
-		return glm::tvec3<T, P>(v.x, v.y, v.w);
+	GLM_INLINE glm::vec<3, T, P> xyw(const glm::vec<4, T, P> &v) {
+		return glm::vec<3, T, P>(v.x, v.y, v.w);
 	}
 
 	// xzx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> xzx(const glm::tvec3<T, P> &v) {
-		return glm::tvec3<T, P>(v.x, v.z, v.x);
+	GLM_INLINE glm::vec<3, T, P> xzx(const glm::vec<3, T, P> &v) {
+		return glm::vec<3, T, P>(v.x, v.z, v.x);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> xzx(const glm::tvec4<T, P> &v) {
-		return glm::tvec3<T, P>(v.x, v.z, v.x);
+	GLM_INLINE glm::vec<3, T, P> xzx(const glm::vec<4, T, P> &v) {
+		return glm::vec<3, T, P>(v.x, v.z, v.x);
 	}
 
 	// xzy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> xzy(const glm::tvec3<T, P> &v) {
-		return glm::tvec3<T, P>(v.x, v.z, v.y);
+	GLM_INLINE glm::vec<3, T, P> xzy(const glm::vec<3, T, P> &v) {
+		return glm::vec<3, T, P>(v.x, v.z, v.y);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> xzy(const glm::tvec4<T, P> &v) {
-		return glm::tvec3<T, P>(v.x, v.z, v.y);
+	GLM_INLINE glm::vec<3, T, P> xzy(const glm::vec<4, T, P> &v) {
+		return glm::vec<3, T, P>(v.x, v.z, v.y);
 	}
 
 	// xzz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> xzz(const glm::tvec3<T, P> &v) {
-		return glm::tvec3<T, P>(v.x, v.z, v.z);
+	GLM_INLINE glm::vec<3, T, P> xzz(const glm::vec<3, T, P> &v) {
+		return glm::vec<3, T, P>(v.x, v.z, v.z);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> xzz(const glm::tvec4<T, P> &v) {
-		return glm::tvec3<T, P>(v.x, v.z, v.z);
+	GLM_INLINE glm::vec<3, T, P> xzz(const glm::vec<4, T, P> &v) {
+		return glm::vec<3, T, P>(v.x, v.z, v.z);
 	}
 
 	// xzw
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> xzw(const glm::tvec4<T, P> &v) {
-		return glm::tvec3<T, P>(v.x, v.z, v.w);
+	GLM_INLINE glm::vec<3, T, P> xzw(const glm::vec<4, T, P> &v) {
+		return glm::vec<3, T, P>(v.x, v.z, v.w);
 	}
 
 	// xwx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> xwx(const glm::tvec4<T, P> &v) {
-		return glm::tvec3<T, P>(v.x, v.w, v.x);
+	GLM_INLINE glm::vec<3, T, P> xwx(const glm::vec<4, T, P> &v) {
+		return glm::vec<3, T, P>(v.x, v.w, v.x);
 	}
 
 	// xwy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> xwy(const glm::tvec4<T, P> &v) {
-		return glm::tvec3<T, P>(v.x, v.w, v.y);
+	GLM_INLINE glm::vec<3, T, P> xwy(const glm::vec<4, T, P> &v) {
+		return glm::vec<3, T, P>(v.x, v.w, v.y);
 	}
 
 	// xwz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> xwz(const glm::tvec4<T, P> &v) {
-		return glm::tvec3<T, P>(v.x, v.w, v.z);
+	GLM_INLINE glm::vec<3, T, P> xwz(const glm::vec<4, T, P> &v) {
+		return glm::vec<3, T, P>(v.x, v.w, v.z);
 	}
 
 	// xww
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> xww(const glm::tvec4<T, P> &v) {
-		return glm::tvec3<T, P>(v.x, v.w, v.w);
+	GLM_INLINE glm::vec<3, T, P> xww(const glm::vec<4, T, P> &v) {
+		return glm::vec<3, T, P>(v.x, v.w, v.w);
 	}
 
 	// yxx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> yxx(const glm::tvec2<T, P> &v) {
-		return glm::tvec3<T, P>(v.y, v.x, v.x);
+	GLM_INLINE glm::vec<3, T, P> yxx(const glm::vec<2, T, P> &v) {
+		return glm::vec<3, T, P>(v.y, v.x, v.x);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> yxx(const glm::tvec3<T, P> &v) {
-		return glm::tvec3<T, P>(v.y, v.x, v.x);
+	GLM_INLINE glm::vec<3, T, P> yxx(const glm::vec<3, T, P> &v) {
+		return glm::vec<3, T, P>(v.y, v.x, v.x);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> yxx(const glm::tvec4<T, P> &v) {
-		return glm::tvec3<T, P>(v.y, v.x, v.x);
+	GLM_INLINE glm::vec<3, T, P> yxx(const glm::vec<4, T, P> &v) {
+		return glm::vec<3, T, P>(v.y, v.x, v.x);
 	}
 
 	// yxy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> yxy(const glm::tvec2<T, P> &v) {
-		return glm::tvec3<T, P>(v.y, v.x, v.y);
+	GLM_INLINE glm::vec<3, T, P> yxy(const glm::vec<2, T, P> &v) {
+		return glm::vec<3, T, P>(v.y, v.x, v.y);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> yxy(const glm::tvec3<T, P> &v) {
-		return glm::tvec3<T, P>(v.y, v.x, v.y);
+	GLM_INLINE glm::vec<3, T, P> yxy(const glm::vec<3, T, P> &v) {
+		return glm::vec<3, T, P>(v.y, v.x, v.y);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> yxy(const glm::tvec4<T, P> &v) {
-		return glm::tvec3<T, P>(v.y, v.x, v.y);
+	GLM_INLINE glm::vec<3, T, P> yxy(const glm::vec<4, T, P> &v) {
+		return glm::vec<3, T, P>(v.y, v.x, v.y);
 	}
 
 	// yxz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> yxz(const glm::tvec3<T, P> &v) {
-		return glm::tvec3<T, P>(v.y, v.x, v.z);
+	GLM_INLINE glm::vec<3, T, P> yxz(const glm::vec<3, T, P> &v) {
+		return glm::vec<3, T, P>(v.y, v.x, v.z);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> yxz(const glm::tvec4<T, P> &v) {
-		return glm::tvec3<T, P>(v.y, v.x, v.z);
+	GLM_INLINE glm::vec<3, T, P> yxz(const glm::vec<4, T, P> &v) {
+		return glm::vec<3, T, P>(v.y, v.x, v.z);
 	}
 
 	// yxw
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> yxw(const glm::tvec4<T, P> &v) {
-		return glm::tvec3<T, P>(v.y, v.x, v.w);
+	GLM_INLINE glm::vec<3, T, P> yxw(const glm::vec<4, T, P> &v) {
+		return glm::vec<3, T, P>(v.y, v.x, v.w);
 	}
 
 	// yyx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> yyx(const glm::tvec2<T, P> &v) {
-		return glm::tvec3<T, P>(v.y, v.y, v.x);
+	GLM_INLINE glm::vec<3, T, P> yyx(const glm::vec<2, T, P> &v) {
+		return glm::vec<3, T, P>(v.y, v.y, v.x);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> yyx(const glm::tvec3<T, P> &v) {
-		return glm::tvec3<T, P>(v.y, v.y, v.x);
+	GLM_INLINE glm::vec<3, T, P> yyx(const glm::vec<3, T, P> &v) {
+		return glm::vec<3, T, P>(v.y, v.y, v.x);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> yyx(const glm::tvec4<T, P> &v) {
-		return glm::tvec3<T, P>(v.y, v.y, v.x);
+	GLM_INLINE glm::vec<3, T, P> yyx(const glm::vec<4, T, P> &v) {
+		return glm::vec<3, T, P>(v.y, v.y, v.x);
 	}
 
 	// yyy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> yyy(const glm::tvec2<T, P> &v) {
-		return glm::tvec3<T, P>(v.y, v.y, v.y);
+	GLM_INLINE glm::vec<3, T, P> yyy(const glm::vec<2, T, P> &v) {
+		return glm::vec<3, T, P>(v.y, v.y, v.y);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> yyy(const glm::tvec3<T, P> &v) {
-		return glm::tvec3<T, P>(v.y, v.y, v.y);
+	GLM_INLINE glm::vec<3, T, P> yyy(const glm::vec<3, T, P> &v) {
+		return glm::vec<3, T, P>(v.y, v.y, v.y);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> yyy(const glm::tvec4<T, P> &v) {
-		return glm::tvec3<T, P>(v.y, v.y, v.y);
+	GLM_INLINE glm::vec<3, T, P> yyy(const glm::vec<4, T, P> &v) {
+		return glm::vec<3, T, P>(v.y, v.y, v.y);
 	}
 
 	// yyz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> yyz(const glm::tvec3<T, P> &v) {
-		return glm::tvec3<T, P>(v.y, v.y, v.z);
+	GLM_INLINE glm::vec<3, T, P> yyz(const glm::vec<3, T, P> &v) {
+		return glm::vec<3, T, P>(v.y, v.y, v.z);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> yyz(const glm::tvec4<T, P> &v) {
-		return glm::tvec3<T, P>(v.y, v.y, v.z);
+	GLM_INLINE glm::vec<3, T, P> yyz(const glm::vec<4, T, P> &v) {
+		return glm::vec<3, T, P>(v.y, v.y, v.z);
 	}
 
 	// yyw
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> yyw(const glm::tvec4<T, P> &v) {
-		return glm::tvec3<T, P>(v.y, v.y, v.w);
+	GLM_INLINE glm::vec<3, T, P> yyw(const glm::vec<4, T, P> &v) {
+		return glm::vec<3, T, P>(v.y, v.y, v.w);
 	}
 
 	// yzx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> yzx(const glm::tvec3<T, P> &v) {
-		return glm::tvec3<T, P>(v.y, v.z, v.x);
+	GLM_INLINE glm::vec<3, T, P> yzx(const glm::vec<3, T, P> &v) {
+		return glm::vec<3, T, P>(v.y, v.z, v.x);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> yzx(const glm::tvec4<T, P> &v) {
-		return glm::tvec3<T, P>(v.y, v.z, v.x);
+	GLM_INLINE glm::vec<3, T, P> yzx(const glm::vec<4, T, P> &v) {
+		return glm::vec<3, T, P>(v.y, v.z, v.x);
 	}
 
 	// yzy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> yzy(const glm::tvec3<T, P> &v) {
-		return glm::tvec3<T, P>(v.y, v.z, v.y);
+	GLM_INLINE glm::vec<3, T, P> yzy(const glm::vec<3, T, P> &v) {
+		return glm::vec<3, T, P>(v.y, v.z, v.y);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> yzy(const glm::tvec4<T, P> &v) {
-		return glm::tvec3<T, P>(v.y, v.z, v.y);
+	GLM_INLINE glm::vec<3, T, P> yzy(const glm::vec<4, T, P> &v) {
+		return glm::vec<3, T, P>(v.y, v.z, v.y);
 	}
 
 	// yzz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> yzz(const glm::tvec3<T, P> &v) {
-		return glm::tvec3<T, P>(v.y, v.z, v.z);
+	GLM_INLINE glm::vec<3, T, P> yzz(const glm::vec<3, T, P> &v) {
+		return glm::vec<3, T, P>(v.y, v.z, v.z);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> yzz(const glm::tvec4<T, P> &v) {
-		return glm::tvec3<T, P>(v.y, v.z, v.z);
+	GLM_INLINE glm::vec<3, T, P> yzz(const glm::vec<4, T, P> &v) {
+		return glm::vec<3, T, P>(v.y, v.z, v.z);
 	}
 
 	// yzw
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> yzw(const glm::tvec4<T, P> &v) {
-		return glm::tvec3<T, P>(v.y, v.z, v.w);
+	GLM_INLINE glm::vec<3, T, P> yzw(const glm::vec<4, T, P> &v) {
+		return glm::vec<3, T, P>(v.y, v.z, v.w);
 	}
 
 	// ywx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> ywx(const glm::tvec4<T, P> &v) {
-		return glm::tvec3<T, P>(v.y, v.w, v.x);
+	GLM_INLINE glm::vec<3, T, P> ywx(const glm::vec<4, T, P> &v) {
+		return glm::vec<3, T, P>(v.y, v.w, v.x);
 	}
 
 	// ywy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> ywy(const glm::tvec4<T, P> &v) {
-		return glm::tvec3<T, P>(v.y, v.w, v.y);
+	GLM_INLINE glm::vec<3, T, P> ywy(const glm::vec<4, T, P> &v) {
+		return glm::vec<3, T, P>(v.y, v.w, v.y);
 	}
 
 	// ywz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> ywz(const glm::tvec4<T, P> &v) {
-		return glm::tvec3<T, P>(v.y, v.w, v.z);
+	GLM_INLINE glm::vec<3, T, P> ywz(const glm::vec<4, T, P> &v) {
+		return glm::vec<3, T, P>(v.y, v.w, v.z);
 	}
 
 	// yww
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> yww(const glm::tvec4<T, P> &v) {
-		return glm::tvec3<T, P>(v.y, v.w, v.w);
+	GLM_INLINE glm::vec<3, T, P> yww(const glm::vec<4, T, P> &v) {
+		return glm::vec<3, T, P>(v.y, v.w, v.w);
 	}
 
 	// zxx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> zxx(const glm::tvec3<T, P> &v) {
-		return glm::tvec3<T, P>(v.z, v.x, v.x);
+	GLM_INLINE glm::vec<3, T, P> zxx(const glm::vec<3, T, P> &v) {
+		return glm::vec<3, T, P>(v.z, v.x, v.x);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> zxx(const glm::tvec4<T, P> &v) {
-		return glm::tvec3<T, P>(v.z, v.x, v.x);
+	GLM_INLINE glm::vec<3, T, P> zxx(const glm::vec<4, T, P> &v) {
+		return glm::vec<3, T, P>(v.z, v.x, v.x);
 	}
 
 	// zxy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> zxy(const glm::tvec3<T, P> &v) {
-		return glm::tvec3<T, P>(v.z, v.x, v.y);
+	GLM_INLINE glm::vec<3, T, P> zxy(const glm::vec<3, T, P> &v) {
+		return glm::vec<3, T, P>(v.z, v.x, v.y);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> zxy(const glm::tvec4<T, P> &v) {
-		return glm::tvec3<T, P>(v.z, v.x, v.y);
+	GLM_INLINE glm::vec<3, T, P> zxy(const glm::vec<4, T, P> &v) {
+		return glm::vec<3, T, P>(v.z, v.x, v.y);
 	}
 
 	// zxz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> zxz(const glm::tvec3<T, P> &v) {
-		return glm::tvec3<T, P>(v.z, v.x, v.z);
+	GLM_INLINE glm::vec<3, T, P> zxz(const glm::vec<3, T, P> &v) {
+		return glm::vec<3, T, P>(v.z, v.x, v.z);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> zxz(const glm::tvec4<T, P> &v) {
-		return glm::tvec3<T, P>(v.z, v.x, v.z);
+	GLM_INLINE glm::vec<3, T, P> zxz(const glm::vec<4, T, P> &v) {
+		return glm::vec<3, T, P>(v.z, v.x, v.z);
 	}
 
 	// zxw
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> zxw(const glm::tvec4<T, P> &v) {
-		return glm::tvec3<T, P>(v.z, v.x, v.w);
+	GLM_INLINE glm::vec<3, T, P> zxw(const glm::vec<4, T, P> &v) {
+		return glm::vec<3, T, P>(v.z, v.x, v.w);
 	}
 
 	// zyx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> zyx(const glm::tvec3<T, P> &v) {
-		return glm::tvec3<T, P>(v.z, v.y, v.x);
+	GLM_INLINE glm::vec<3, T, P> zyx(const glm::vec<3, T, P> &v) {
+		return glm::vec<3, T, P>(v.z, v.y, v.x);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> zyx(const glm::tvec4<T, P> &v) {
-		return glm::tvec3<T, P>(v.z, v.y, v.x);
+	GLM_INLINE glm::vec<3, T, P> zyx(const glm::vec<4, T, P> &v) {
+		return glm::vec<3, T, P>(v.z, v.y, v.x);
 	}
 
 	// zyy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> zyy(const glm::tvec3<T, P> &v) {
-		return glm::tvec3<T, P>(v.z, v.y, v.y);
+	GLM_INLINE glm::vec<3, T, P> zyy(const glm::vec<3, T, P> &v) {
+		return glm::vec<3, T, P>(v.z, v.y, v.y);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> zyy(const glm::tvec4<T, P> &v) {
-		return glm::tvec3<T, P>(v.z, v.y, v.y);
+	GLM_INLINE glm::vec<3, T, P> zyy(const glm::vec<4, T, P> &v) {
+		return glm::vec<3, T, P>(v.z, v.y, v.y);
 	}
 
 	// zyz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> zyz(const glm::tvec3<T, P> &v) {
-		return glm::tvec3<T, P>(v.z, v.y, v.z);
+	GLM_INLINE glm::vec<3, T, P> zyz(const glm::vec<3, T, P> &v) {
+		return glm::vec<3, T, P>(v.z, v.y, v.z);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> zyz(const glm::tvec4<T, P> &v) {
-		return glm::tvec3<T, P>(v.z, v.y, v.z);
+	GLM_INLINE glm::vec<3, T, P> zyz(const glm::vec<4, T, P> &v) {
+		return glm::vec<3, T, P>(v.z, v.y, v.z);
 	}
 
 	// zyw
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> zyw(const glm::tvec4<T, P> &v) {
-		return glm::tvec3<T, P>(v.z, v.y, v.w);
+	GLM_INLINE glm::vec<3, T, P> zyw(const glm::vec<4, T, P> &v) {
+		return glm::vec<3, T, P>(v.z, v.y, v.w);
 	}
 
 	// zzx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> zzx(const glm::tvec3<T, P> &v) {
-		return glm::tvec3<T, P>(v.z, v.z, v.x);
+	GLM_INLINE glm::vec<3, T, P> zzx(const glm::vec<3, T, P> &v) {
+		return glm::vec<3, T, P>(v.z, v.z, v.x);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> zzx(const glm::tvec4<T, P> &v) {
-		return glm::tvec3<T, P>(v.z, v.z, v.x);
+	GLM_INLINE glm::vec<3, T, P> zzx(const glm::vec<4, T, P> &v) {
+		return glm::vec<3, T, P>(v.z, v.z, v.x);
 	}
 
 	// zzy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> zzy(const glm::tvec3<T, P> &v) {
-		return glm::tvec3<T, P>(v.z, v.z, v.y);
+	GLM_INLINE glm::vec<3, T, P> zzy(const glm::vec<3, T, P> &v) {
+		return glm::vec<3, T, P>(v.z, v.z, v.y);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> zzy(const glm::tvec4<T, P> &v) {
-		return glm::tvec3<T, P>(v.z, v.z, v.y);
+	GLM_INLINE glm::vec<3, T, P> zzy(const glm::vec<4, T, P> &v) {
+		return glm::vec<3, T, P>(v.z, v.z, v.y);
 	}
 
 	// zzz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> zzz(const glm::tvec3<T, P> &v) {
-		return glm::tvec3<T, P>(v.z, v.z, v.z);
+	GLM_INLINE glm::vec<3, T, P> zzz(const glm::vec<3, T, P> &v) {
+		return glm::vec<3, T, P>(v.z, v.z, v.z);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> zzz(const glm::tvec4<T, P> &v) {
-		return glm::tvec3<T, P>(v.z, v.z, v.z);
+	GLM_INLINE glm::vec<3, T, P> zzz(const glm::vec<4, T, P> &v) {
+		return glm::vec<3, T, P>(v.z, v.z, v.z);
 	}
 
 	// zzw
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> zzw(const glm::tvec4<T, P> &v) {
-		return glm::tvec3<T, P>(v.z, v.z, v.w);
+	GLM_INLINE glm::vec<3, T, P> zzw(const glm::vec<4, T, P> &v) {
+		return glm::vec<3, T, P>(v.z, v.z, v.w);
 	}
 
 	// zwx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> zwx(const glm::tvec4<T, P> &v) {
-		return glm::tvec3<T, P>(v.z, v.w, v.x);
+	GLM_INLINE glm::vec<3, T, P> zwx(const glm::vec<4, T, P> &v) {
+		return glm::vec<3, T, P>(v.z, v.w, v.x);
 	}
 
 	// zwy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> zwy(const glm::tvec4<T, P> &v) {
-		return glm::tvec3<T, P>(v.z, v.w, v.y);
+	GLM_INLINE glm::vec<3, T, P> zwy(const glm::vec<4, T, P> &v) {
+		return glm::vec<3, T, P>(v.z, v.w, v.y);
 	}
 
 	// zwz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> zwz(const glm::tvec4<T, P> &v) {
-		return glm::tvec3<T, P>(v.z, v.w, v.z);
+	GLM_INLINE glm::vec<3, T, P> zwz(const glm::vec<4, T, P> &v) {
+		return glm::vec<3, T, P>(v.z, v.w, v.z);
 	}
 
 	// zww
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> zww(const glm::tvec4<T, P> &v) {
-		return glm::tvec3<T, P>(v.z, v.w, v.w);
+	GLM_INLINE glm::vec<3, T, P> zww(const glm::vec<4, T, P> &v) {
+		return glm::vec<3, T, P>(v.z, v.w, v.w);
 	}
 
 	// wxx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> wxx(const glm::tvec4<T, P> &v) {
-		return glm::tvec3<T, P>(v.w, v.x, v.x);
+	GLM_INLINE glm::vec<3, T, P> wxx(const glm::vec<4, T, P> &v) {
+		return glm::vec<3, T, P>(v.w, v.x, v.x);
 	}
 
 	// wxy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> wxy(const glm::tvec4<T, P> &v) {
-		return glm::tvec3<T, P>(v.w, v.x, v.y);
+	GLM_INLINE glm::vec<3, T, P> wxy(const glm::vec<4, T, P> &v) {
+		return glm::vec<3, T, P>(v.w, v.x, v.y);
 	}
 
 	// wxz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> wxz(const glm::tvec4<T, P> &v) {
-		return glm::tvec3<T, P>(v.w, v.x, v.z);
+	GLM_INLINE glm::vec<3, T, P> wxz(const glm::vec<4, T, P> &v) {
+		return glm::vec<3, T, P>(v.w, v.x, v.z);
 	}
 
 	// wxw
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> wxw(const glm::tvec4<T, P> &v) {
-		return glm::tvec3<T, P>(v.w, v.x, v.w);
+	GLM_INLINE glm::vec<3, T, P> wxw(const glm::vec<4, T, P> &v) {
+		return glm::vec<3, T, P>(v.w, v.x, v.w);
 	}
 
 	// wyx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> wyx(const glm::tvec4<T, P> &v) {
-		return glm::tvec3<T, P>(v.w, v.y, v.x);
+	GLM_INLINE glm::vec<3, T, P> wyx(const glm::vec<4, T, P> &v) {
+		return glm::vec<3, T, P>(v.w, v.y, v.x);
 	}
 
 	// wyy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> wyy(const glm::tvec4<T, P> &v) {
-		return glm::tvec3<T, P>(v.w, v.y, v.y);
+	GLM_INLINE glm::vec<3, T, P> wyy(const glm::vec<4, T, P> &v) {
+		return glm::vec<3, T, P>(v.w, v.y, v.y);
 	}
 
 	// wyz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> wyz(const glm::tvec4<T, P> &v) {
-		return glm::tvec3<T, P>(v.w, v.y, v.z);
+	GLM_INLINE glm::vec<3, T, P> wyz(const glm::vec<4, T, P> &v) {
+		return glm::vec<3, T, P>(v.w, v.y, v.z);
 	}
 
 	// wyw
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> wyw(const glm::tvec4<T, P> &v) {
-		return glm::tvec3<T, P>(v.w, v.y, v.w);
+	GLM_INLINE glm::vec<3, T, P> wyw(const glm::vec<4, T, P> &v) {
+		return glm::vec<3, T, P>(v.w, v.y, v.w);
 	}
 
 	// wzx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> wzx(const glm::tvec4<T, P> &v) {
-		return glm::tvec3<T, P>(v.w, v.z, v.x);
+	GLM_INLINE glm::vec<3, T, P> wzx(const glm::vec<4, T, P> &v) {
+		return glm::vec<3, T, P>(v.w, v.z, v.x);
 	}
 
 	// wzy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> wzy(const glm::tvec4<T, P> &v) {
-		return glm::tvec3<T, P>(v.w, v.z, v.y);
+	GLM_INLINE glm::vec<3, T, P> wzy(const glm::vec<4, T, P> &v) {
+		return glm::vec<3, T, P>(v.w, v.z, v.y);
 	}
 
 	// wzz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> wzz(const glm::tvec4<T, P> &v) {
-		return glm::tvec3<T, P>(v.w, v.z, v.z);
+	GLM_INLINE glm::vec<3, T, P> wzz(const glm::vec<4, T, P> &v) {
+		return glm::vec<3, T, P>(v.w, v.z, v.z);
 	}
 
 	// wzw
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> wzw(const glm::tvec4<T, P> &v) {
-		return glm::tvec3<T, P>(v.w, v.z, v.w);
+	GLM_INLINE glm::vec<3, T, P> wzw(const glm::vec<4, T, P> &v) {
+		return glm::vec<3, T, P>(v.w, v.z, v.w);
 	}
 
 	// wwx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> wwx(const glm::tvec4<T, P> &v) {
-		return glm::tvec3<T, P>(v.w, v.w, v.x);
+	GLM_INLINE glm::vec<3, T, P> wwx(const glm::vec<4, T, P> &v) {
+		return glm::vec<3, T, P>(v.w, v.w, v.x);
 	}
 
 	// wwy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> wwy(const glm::tvec4<T, P> &v) {
-		return glm::tvec3<T, P>(v.w, v.w, v.y);
+	GLM_INLINE glm::vec<3, T, P> wwy(const glm::vec<4, T, P> &v) {
+		return glm::vec<3, T, P>(v.w, v.w, v.y);
 	}
 
 	// wwz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> wwz(const glm::tvec4<T, P> &v) {
-		return glm::tvec3<T, P>(v.w, v.w, v.z);
+	GLM_INLINE glm::vec<3, T, P> wwz(const glm::vec<4, T, P> &v) {
+		return glm::vec<3, T, P>(v.w, v.w, v.z);
 	}
 
 	// www
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec3<T, P> www(const glm::tvec4<T, P> &v) {
-		return glm::tvec3<T, P>(v.w, v.w, v.w);
+	GLM_INLINE glm::vec<3, T, P> www(const glm::vec<4, T, P> &v) {
+		return glm::vec<3, T, P>(v.w, v.w, v.w);
 	}
 
 	// xxxx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xxxx(const glm::tvec1<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.x, v.x, v.x);
+	GLM_INLINE glm::vec<4, T, P> xxxx(const glm::vec<1, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.x, v.x, v.x);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xxxx(const glm::tvec2<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.x, v.x, v.x);
+	GLM_INLINE glm::vec<4, T, P> xxxx(const glm::vec<2, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.x, v.x, v.x);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xxxx(const glm::tvec3<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.x, v.x, v.x);
+	GLM_INLINE glm::vec<4, T, P> xxxx(const glm::vec<3, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.x, v.x, v.x);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xxxx(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.x, v.x, v.x);
+	GLM_INLINE glm::vec<4, T, P> xxxx(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.x, v.x, v.x);
 	}
 
 	// xxxy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xxxy(const glm::tvec2<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.x, v.x, v.y);
+	GLM_INLINE glm::vec<4, T, P> xxxy(const glm::vec<2, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.x, v.x, v.y);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xxxy(const glm::tvec3<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.x, v.x, v.y);
+	GLM_INLINE glm::vec<4, T, P> xxxy(const glm::vec<3, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.x, v.x, v.y);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xxxy(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.x, v.x, v.y);
+	GLM_INLINE glm::vec<4, T, P> xxxy(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.x, v.x, v.y);
 	}
 
 	// xxxz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xxxz(const glm::tvec3<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.x, v.x, v.z);
+	GLM_INLINE glm::vec<4, T, P> xxxz(const glm::vec<3, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.x, v.x, v.z);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xxxz(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.x, v.x, v.z);
+	GLM_INLINE glm::vec<4, T, P> xxxz(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.x, v.x, v.z);
 	}
 
 	// xxxw
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xxxw(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.x, v.x, v.w);
+	GLM_INLINE glm::vec<4, T, P> xxxw(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.x, v.x, v.w);
 	}
 
 	// xxyx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xxyx(const glm::tvec2<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.x, v.y, v.x);
+	GLM_INLINE glm::vec<4, T, P> xxyx(const glm::vec<2, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.x, v.y, v.x);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xxyx(const glm::tvec3<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.x, v.y, v.x);
+	GLM_INLINE glm::vec<4, T, P> xxyx(const glm::vec<3, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.x, v.y, v.x);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xxyx(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.x, v.y, v.x);
+	GLM_INLINE glm::vec<4, T, P> xxyx(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.x, v.y, v.x);
 	}
 
 	// xxyy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xxyy(const glm::tvec2<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.x, v.y, v.y);
+	GLM_INLINE glm::vec<4, T, P> xxyy(const glm::vec<2, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.x, v.y, v.y);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xxyy(const glm::tvec3<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.x, v.y, v.y);
+	GLM_INLINE glm::vec<4, T, P> xxyy(const glm::vec<3, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.x, v.y, v.y);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xxyy(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.x, v.y, v.y);
+	GLM_INLINE glm::vec<4, T, P> xxyy(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.x, v.y, v.y);
 	}
 
 	// xxyz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xxyz(const glm::tvec3<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.x, v.y, v.z);
+	GLM_INLINE glm::vec<4, T, P> xxyz(const glm::vec<3, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.x, v.y, v.z);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xxyz(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.x, v.y, v.z);
+	GLM_INLINE glm::vec<4, T, P> xxyz(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.x, v.y, v.z);
 	}
 
 	// xxyw
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xxyw(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.x, v.y, v.w);
+	GLM_INLINE glm::vec<4, T, P> xxyw(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.x, v.y, v.w);
 	}
 
 	// xxzx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xxzx(const glm::tvec3<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.x, v.z, v.x);
+	GLM_INLINE glm::vec<4, T, P> xxzx(const glm::vec<3, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.x, v.z, v.x);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xxzx(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.x, v.z, v.x);
+	GLM_INLINE glm::vec<4, T, P> xxzx(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.x, v.z, v.x);
 	}
 
 	// xxzy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xxzy(const glm::tvec3<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.x, v.z, v.y);
+	GLM_INLINE glm::vec<4, T, P> xxzy(const glm::vec<3, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.x, v.z, v.y);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xxzy(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.x, v.z, v.y);
+	GLM_INLINE glm::vec<4, T, P> xxzy(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.x, v.z, v.y);
 	}
 
 	// xxzz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xxzz(const glm::tvec3<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.x, v.z, v.z);
+	GLM_INLINE glm::vec<4, T, P> xxzz(const glm::vec<3, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.x, v.z, v.z);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xxzz(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.x, v.z, v.z);
+	GLM_INLINE glm::vec<4, T, P> xxzz(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.x, v.z, v.z);
 	}
 
 	// xxzw
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xxzw(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.x, v.z, v.w);
+	GLM_INLINE glm::vec<4, T, P> xxzw(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.x, v.z, v.w);
 	}
 
 	// xxwx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xxwx(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.x, v.w, v.x);
+	GLM_INLINE glm::vec<4, T, P> xxwx(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.x, v.w, v.x);
 	}
 
 	// xxwy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xxwy(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.x, v.w, v.y);
+	GLM_INLINE glm::vec<4, T, P> xxwy(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.x, v.w, v.y);
 	}
 
 	// xxwz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xxwz(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.x, v.w, v.z);
+	GLM_INLINE glm::vec<4, T, P> xxwz(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.x, v.w, v.z);
 	}
 
 	// xxww
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xxww(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.x, v.w, v.w);
+	GLM_INLINE glm::vec<4, T, P> xxww(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.x, v.w, v.w);
 	}
 
 	// xyxx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xyxx(const glm::tvec2<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.y, v.x, v.x);
+	GLM_INLINE glm::vec<4, T, P> xyxx(const glm::vec<2, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.y, v.x, v.x);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xyxx(const glm::tvec3<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.y, v.x, v.x);
+	GLM_INLINE glm::vec<4, T, P> xyxx(const glm::vec<3, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.y, v.x, v.x);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xyxx(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.y, v.x, v.x);
+	GLM_INLINE glm::vec<4, T, P> xyxx(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.y, v.x, v.x);
 	}
 
 	// xyxy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xyxy(const glm::tvec2<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.y, v.x, v.y);
+	GLM_INLINE glm::vec<4, T, P> xyxy(const glm::vec<2, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.y, v.x, v.y);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xyxy(const glm::tvec3<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.y, v.x, v.y);
+	GLM_INLINE glm::vec<4, T, P> xyxy(const glm::vec<3, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.y, v.x, v.y);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xyxy(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.y, v.x, v.y);
+	GLM_INLINE glm::vec<4, T, P> xyxy(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.y, v.x, v.y);
 	}
 
 	// xyxz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xyxz(const glm::tvec3<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.y, v.x, v.z);
+	GLM_INLINE glm::vec<4, T, P> xyxz(const glm::vec<3, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.y, v.x, v.z);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xyxz(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.y, v.x, v.z);
+	GLM_INLINE glm::vec<4, T, P> xyxz(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.y, v.x, v.z);
 	}
 
 	// xyxw
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xyxw(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.y, v.x, v.w);
+	GLM_INLINE glm::vec<4, T, P> xyxw(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.y, v.x, v.w);
 	}
 
 	// xyyx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xyyx(const glm::tvec2<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.y, v.y, v.x);
+	GLM_INLINE glm::vec<4, T, P> xyyx(const glm::vec<2, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.y, v.y, v.x);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xyyx(const glm::tvec3<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.y, v.y, v.x);
+	GLM_INLINE glm::vec<4, T, P> xyyx(const glm::vec<3, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.y, v.y, v.x);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xyyx(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.y, v.y, v.x);
+	GLM_INLINE glm::vec<4, T, P> xyyx(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.y, v.y, v.x);
 	}
 
 	// xyyy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xyyy(const glm::tvec2<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.y, v.y, v.y);
+	GLM_INLINE glm::vec<4, T, P> xyyy(const glm::vec<2, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.y, v.y, v.y);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xyyy(const glm::tvec3<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.y, v.y, v.y);
+	GLM_INLINE glm::vec<4, T, P> xyyy(const glm::vec<3, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.y, v.y, v.y);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xyyy(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.y, v.y, v.y);
+	GLM_INLINE glm::vec<4, T, P> xyyy(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.y, v.y, v.y);
 	}
 
 	// xyyz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xyyz(const glm::tvec3<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.y, v.y, v.z);
+	GLM_INLINE glm::vec<4, T, P> xyyz(const glm::vec<3, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.y, v.y, v.z);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xyyz(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.y, v.y, v.z);
+	GLM_INLINE glm::vec<4, T, P> xyyz(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.y, v.y, v.z);
 	}
 
 	// xyyw
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xyyw(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.y, v.y, v.w);
+	GLM_INLINE glm::vec<4, T, P> xyyw(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.y, v.y, v.w);
 	}
 
 	// xyzx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xyzx(const glm::tvec3<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.y, v.z, v.x);
+	GLM_INLINE glm::vec<4, T, P> xyzx(const glm::vec<3, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.y, v.z, v.x);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xyzx(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.y, v.z, v.x);
+	GLM_INLINE glm::vec<4, T, P> xyzx(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.y, v.z, v.x);
 	}
 
 	// xyzy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xyzy(const glm::tvec3<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.y, v.z, v.y);
+	GLM_INLINE glm::vec<4, T, P> xyzy(const glm::vec<3, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.y, v.z, v.y);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xyzy(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.y, v.z, v.y);
+	GLM_INLINE glm::vec<4, T, P> xyzy(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.y, v.z, v.y);
 	}
 
 	// xyzz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xyzz(const glm::tvec3<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.y, v.z, v.z);
+	GLM_INLINE glm::vec<4, T, P> xyzz(const glm::vec<3, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.y, v.z, v.z);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xyzz(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.y, v.z, v.z);
+	GLM_INLINE glm::vec<4, T, P> xyzz(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.y, v.z, v.z);
 	}
 
 	// xyzw
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xyzw(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.y, v.z, v.w);
+	GLM_INLINE glm::vec<4, T, P> xyzw(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.y, v.z, v.w);
 	}
 
 	// xywx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xywx(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.y, v.w, v.x);
+	GLM_INLINE glm::vec<4, T, P> xywx(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.y, v.w, v.x);
 	}
 
 	// xywy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xywy(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.y, v.w, v.y);
+	GLM_INLINE glm::vec<4, T, P> xywy(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.y, v.w, v.y);
 	}
 
 	// xywz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xywz(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.y, v.w, v.z);
+	GLM_INLINE glm::vec<4, T, P> xywz(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.y, v.w, v.z);
 	}
 
 	// xyww
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xyww(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.y, v.w, v.w);
+	GLM_INLINE glm::vec<4, T, P> xyww(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.y, v.w, v.w);
 	}
 
 	// xzxx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xzxx(const glm::tvec3<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.z, v.x, v.x);
+	GLM_INLINE glm::vec<4, T, P> xzxx(const glm::vec<3, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.z, v.x, v.x);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xzxx(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.z, v.x, v.x);
+	GLM_INLINE glm::vec<4, T, P> xzxx(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.z, v.x, v.x);
 	}
 
 	// xzxy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xzxy(const glm::tvec3<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.z, v.x, v.y);
+	GLM_INLINE glm::vec<4, T, P> xzxy(const glm::vec<3, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.z, v.x, v.y);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xzxy(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.z, v.x, v.y);
+	GLM_INLINE glm::vec<4, T, P> xzxy(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.z, v.x, v.y);
 	}
 
 	// xzxz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xzxz(const glm::tvec3<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.z, v.x, v.z);
+	GLM_INLINE glm::vec<4, T, P> xzxz(const glm::vec<3, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.z, v.x, v.z);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xzxz(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.z, v.x, v.z);
+	GLM_INLINE glm::vec<4, T, P> xzxz(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.z, v.x, v.z);
 	}
 
 	// xzxw
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xzxw(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.z, v.x, v.w);
+	GLM_INLINE glm::vec<4, T, P> xzxw(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.z, v.x, v.w);
 	}
 
 	// xzyx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xzyx(const glm::tvec3<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.z, v.y, v.x);
+	GLM_INLINE glm::vec<4, T, P> xzyx(const glm::vec<3, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.z, v.y, v.x);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xzyx(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.z, v.y, v.x);
+	GLM_INLINE glm::vec<4, T, P> xzyx(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.z, v.y, v.x);
 	}
 
 	// xzyy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xzyy(const glm::tvec3<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.z, v.y, v.y);
+	GLM_INLINE glm::vec<4, T, P> xzyy(const glm::vec<3, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.z, v.y, v.y);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xzyy(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.z, v.y, v.y);
+	GLM_INLINE glm::vec<4, T, P> xzyy(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.z, v.y, v.y);
 	}
 
 	// xzyz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xzyz(const glm::tvec3<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.z, v.y, v.z);
+	GLM_INLINE glm::vec<4, T, P> xzyz(const glm::vec<3, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.z, v.y, v.z);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xzyz(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.z, v.y, v.z);
+	GLM_INLINE glm::vec<4, T, P> xzyz(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.z, v.y, v.z);
 	}
 
 	// xzyw
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xzyw(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.z, v.y, v.w);
+	GLM_INLINE glm::vec<4, T, P> xzyw(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.z, v.y, v.w);
 	}
 
 	// xzzx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xzzx(const glm::tvec3<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.z, v.z, v.x);
+	GLM_INLINE glm::vec<4, T, P> xzzx(const glm::vec<3, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.z, v.z, v.x);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xzzx(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.z, v.z, v.x);
+	GLM_INLINE glm::vec<4, T, P> xzzx(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.z, v.z, v.x);
 	}
 
 	// xzzy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xzzy(const glm::tvec3<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.z, v.z, v.y);
+	GLM_INLINE glm::vec<4, T, P> xzzy(const glm::vec<3, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.z, v.z, v.y);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xzzy(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.z, v.z, v.y);
+	GLM_INLINE glm::vec<4, T, P> xzzy(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.z, v.z, v.y);
 	}
 
 	// xzzz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xzzz(const glm::tvec3<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.z, v.z, v.z);
+	GLM_INLINE glm::vec<4, T, P> xzzz(const glm::vec<3, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.z, v.z, v.z);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xzzz(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.z, v.z, v.z);
+	GLM_INLINE glm::vec<4, T, P> xzzz(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.z, v.z, v.z);
 	}
 
 	// xzzw
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xzzw(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.z, v.z, v.w);
+	GLM_INLINE glm::vec<4, T, P> xzzw(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.z, v.z, v.w);
 	}
 
 	// xzwx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xzwx(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.z, v.w, v.x);
+	GLM_INLINE glm::vec<4, T, P> xzwx(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.z, v.w, v.x);
 	}
 
 	// xzwy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xzwy(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.z, v.w, v.y);
+	GLM_INLINE glm::vec<4, T, P> xzwy(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.z, v.w, v.y);
 	}
 
 	// xzwz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xzwz(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.z, v.w, v.z);
+	GLM_INLINE glm::vec<4, T, P> xzwz(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.z, v.w, v.z);
 	}
 
 	// xzww
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xzww(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.z, v.w, v.w);
+	GLM_INLINE glm::vec<4, T, P> xzww(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.z, v.w, v.w);
 	}
 
 	// xwxx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xwxx(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.w, v.x, v.x);
+	GLM_INLINE glm::vec<4, T, P> xwxx(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.w, v.x, v.x);
 	}
 
 	// xwxy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xwxy(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.w, v.x, v.y);
+	GLM_INLINE glm::vec<4, T, P> xwxy(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.w, v.x, v.y);
 	}
 
 	// xwxz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xwxz(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.w, v.x, v.z);
+	GLM_INLINE glm::vec<4, T, P> xwxz(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.w, v.x, v.z);
 	}
 
 	// xwxw
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xwxw(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.w, v.x, v.w);
+	GLM_INLINE glm::vec<4, T, P> xwxw(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.w, v.x, v.w);
 	}
 
 	// xwyx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xwyx(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.w, v.y, v.x);
+	GLM_INLINE glm::vec<4, T, P> xwyx(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.w, v.y, v.x);
 	}
 
 	// xwyy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xwyy(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.w, v.y, v.y);
+	GLM_INLINE glm::vec<4, T, P> xwyy(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.w, v.y, v.y);
 	}
 
 	// xwyz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xwyz(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.w, v.y, v.z);
+	GLM_INLINE glm::vec<4, T, P> xwyz(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.w, v.y, v.z);
 	}
 
 	// xwyw
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xwyw(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.w, v.y, v.w);
+	GLM_INLINE glm::vec<4, T, P> xwyw(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.w, v.y, v.w);
 	}
 
 	// xwzx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xwzx(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.w, v.z, v.x);
+	GLM_INLINE glm::vec<4, T, P> xwzx(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.w, v.z, v.x);
 	}
 
 	// xwzy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xwzy(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.w, v.z, v.y);
+	GLM_INLINE glm::vec<4, T, P> xwzy(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.w, v.z, v.y);
 	}
 
 	// xwzz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xwzz(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.w, v.z, v.z);
+	GLM_INLINE glm::vec<4, T, P> xwzz(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.w, v.z, v.z);
 	}
 
 	// xwzw
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xwzw(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.w, v.z, v.w);
+	GLM_INLINE glm::vec<4, T, P> xwzw(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.w, v.z, v.w);
 	}
 
 	// xwwx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xwwx(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.w, v.w, v.x);
+	GLM_INLINE glm::vec<4, T, P> xwwx(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.w, v.w, v.x);
 	}
 
 	// xwwy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xwwy(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.w, v.w, v.y);
+	GLM_INLINE glm::vec<4, T, P> xwwy(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.w, v.w, v.y);
 	}
 
 	// xwwz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xwwz(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.w, v.w, v.z);
+	GLM_INLINE glm::vec<4, T, P> xwwz(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.w, v.w, v.z);
 	}
 
 	// xwww
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> xwww(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.x, v.w, v.w, v.w);
+	GLM_INLINE glm::vec<4, T, P> xwww(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.x, v.w, v.w, v.w);
 	}
 
 	// yxxx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yxxx(const glm::tvec2<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.x, v.x, v.x);
+	GLM_INLINE glm::vec<4, T, P> yxxx(const glm::vec<2, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.x, v.x, v.x);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yxxx(const glm::tvec3<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.x, v.x, v.x);
+	GLM_INLINE glm::vec<4, T, P> yxxx(const glm::vec<3, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.x, v.x, v.x);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yxxx(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.x, v.x, v.x);
+	GLM_INLINE glm::vec<4, T, P> yxxx(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.x, v.x, v.x);
 	}
 
 	// yxxy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yxxy(const glm::tvec2<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.x, v.x, v.y);
+	GLM_INLINE glm::vec<4, T, P> yxxy(const glm::vec<2, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.x, v.x, v.y);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yxxy(const glm::tvec3<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.x, v.x, v.y);
+	GLM_INLINE glm::vec<4, T, P> yxxy(const glm::vec<3, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.x, v.x, v.y);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yxxy(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.x, v.x, v.y);
+	GLM_INLINE glm::vec<4, T, P> yxxy(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.x, v.x, v.y);
 	}
 
 	// yxxz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yxxz(const glm::tvec3<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.x, v.x, v.z);
+	GLM_INLINE glm::vec<4, T, P> yxxz(const glm::vec<3, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.x, v.x, v.z);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yxxz(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.x, v.x, v.z);
+	GLM_INLINE glm::vec<4, T, P> yxxz(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.x, v.x, v.z);
 	}
 
 	// yxxw
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yxxw(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.x, v.x, v.w);
+	GLM_INLINE glm::vec<4, T, P> yxxw(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.x, v.x, v.w);
 	}
 
 	// yxyx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yxyx(const glm::tvec2<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.x, v.y, v.x);
+	GLM_INLINE glm::vec<4, T, P> yxyx(const glm::vec<2, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.x, v.y, v.x);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yxyx(const glm::tvec3<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.x, v.y, v.x);
+	GLM_INLINE glm::vec<4, T, P> yxyx(const glm::vec<3, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.x, v.y, v.x);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yxyx(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.x, v.y, v.x);
+	GLM_INLINE glm::vec<4, T, P> yxyx(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.x, v.y, v.x);
 	}
 
 	// yxyy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yxyy(const glm::tvec2<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.x, v.y, v.y);
+	GLM_INLINE glm::vec<4, T, P> yxyy(const glm::vec<2, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.x, v.y, v.y);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yxyy(const glm::tvec3<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.x, v.y, v.y);
+	GLM_INLINE glm::vec<4, T, P> yxyy(const glm::vec<3, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.x, v.y, v.y);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yxyy(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.x, v.y, v.y);
+	GLM_INLINE glm::vec<4, T, P> yxyy(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.x, v.y, v.y);
 	}
 
 	// yxyz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yxyz(const glm::tvec3<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.x, v.y, v.z);
+	GLM_INLINE glm::vec<4, T, P> yxyz(const glm::vec<3, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.x, v.y, v.z);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yxyz(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.x, v.y, v.z);
+	GLM_INLINE glm::vec<4, T, P> yxyz(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.x, v.y, v.z);
 	}
 
 	// yxyw
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yxyw(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.x, v.y, v.w);
+	GLM_INLINE glm::vec<4, T, P> yxyw(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.x, v.y, v.w);
 	}
 
 	// yxzx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yxzx(const glm::tvec3<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.x, v.z, v.x);
+	GLM_INLINE glm::vec<4, T, P> yxzx(const glm::vec<3, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.x, v.z, v.x);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yxzx(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.x, v.z, v.x);
+	GLM_INLINE glm::vec<4, T, P> yxzx(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.x, v.z, v.x);
 	}
 
 	// yxzy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yxzy(const glm::tvec3<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.x, v.z, v.y);
+	GLM_INLINE glm::vec<4, T, P> yxzy(const glm::vec<3, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.x, v.z, v.y);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yxzy(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.x, v.z, v.y);
+	GLM_INLINE glm::vec<4, T, P> yxzy(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.x, v.z, v.y);
 	}
 
 	// yxzz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yxzz(const glm::tvec3<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.x, v.z, v.z);
+	GLM_INLINE glm::vec<4, T, P> yxzz(const glm::vec<3, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.x, v.z, v.z);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yxzz(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.x, v.z, v.z);
+	GLM_INLINE glm::vec<4, T, P> yxzz(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.x, v.z, v.z);
 	}
 
 	// yxzw
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yxzw(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.x, v.z, v.w);
+	GLM_INLINE glm::vec<4, T, P> yxzw(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.x, v.z, v.w);
 	}
 
 	// yxwx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yxwx(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.x, v.w, v.x);
+	GLM_INLINE glm::vec<4, T, P> yxwx(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.x, v.w, v.x);
 	}
 
 	// yxwy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yxwy(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.x, v.w, v.y);
+	GLM_INLINE glm::vec<4, T, P> yxwy(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.x, v.w, v.y);
 	}
 
 	// yxwz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yxwz(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.x, v.w, v.z);
+	GLM_INLINE glm::vec<4, T, P> yxwz(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.x, v.w, v.z);
 	}
 
 	// yxww
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yxww(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.x, v.w, v.w);
+	GLM_INLINE glm::vec<4, T, P> yxww(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.x, v.w, v.w);
 	}
 
 	// yyxx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yyxx(const glm::tvec2<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.y, v.x, v.x);
+	GLM_INLINE glm::vec<4, T, P> yyxx(const glm::vec<2, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.y, v.x, v.x);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yyxx(const glm::tvec3<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.y, v.x, v.x);
+	GLM_INLINE glm::vec<4, T, P> yyxx(const glm::vec<3, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.y, v.x, v.x);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yyxx(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.y, v.x, v.x);
+	GLM_INLINE glm::vec<4, T, P> yyxx(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.y, v.x, v.x);
 	}
 
 	// yyxy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yyxy(const glm::tvec2<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.y, v.x, v.y);
+	GLM_INLINE glm::vec<4, T, P> yyxy(const glm::vec<2, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.y, v.x, v.y);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yyxy(const glm::tvec3<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.y, v.x, v.y);
+	GLM_INLINE glm::vec<4, T, P> yyxy(const glm::vec<3, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.y, v.x, v.y);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yyxy(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.y, v.x, v.y);
+	GLM_INLINE glm::vec<4, T, P> yyxy(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.y, v.x, v.y);
 	}
 
 	// yyxz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yyxz(const glm::tvec3<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.y, v.x, v.z);
+	GLM_INLINE glm::vec<4, T, P> yyxz(const glm::vec<3, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.y, v.x, v.z);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yyxz(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.y, v.x, v.z);
+	GLM_INLINE glm::vec<4, T, P> yyxz(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.y, v.x, v.z);
 	}
 
 	// yyxw
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yyxw(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.y, v.x, v.w);
+	GLM_INLINE glm::vec<4, T, P> yyxw(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.y, v.x, v.w);
 	}
 
 	// yyyx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yyyx(const glm::tvec2<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.y, v.y, v.x);
+	GLM_INLINE glm::vec<4, T, P> yyyx(const glm::vec<2, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.y, v.y, v.x);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yyyx(const glm::tvec3<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.y, v.y, v.x);
+	GLM_INLINE glm::vec<4, T, P> yyyx(const glm::vec<3, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.y, v.y, v.x);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yyyx(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.y, v.y, v.x);
+	GLM_INLINE glm::vec<4, T, P> yyyx(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.y, v.y, v.x);
 	}
 
 	// yyyy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yyyy(const glm::tvec2<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.y, v.y, v.y);
+	GLM_INLINE glm::vec<4, T, P> yyyy(const glm::vec<2, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.y, v.y, v.y);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yyyy(const glm::tvec3<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.y, v.y, v.y);
+	GLM_INLINE glm::vec<4, T, P> yyyy(const glm::vec<3, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.y, v.y, v.y);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yyyy(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.y, v.y, v.y);
+	GLM_INLINE glm::vec<4, T, P> yyyy(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.y, v.y, v.y);
 	}
 
 	// yyyz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yyyz(const glm::tvec3<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.y, v.y, v.z);
+	GLM_INLINE glm::vec<4, T, P> yyyz(const glm::vec<3, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.y, v.y, v.z);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yyyz(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.y, v.y, v.z);
+	GLM_INLINE glm::vec<4, T, P> yyyz(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.y, v.y, v.z);
 	}
 
 	// yyyw
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yyyw(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.y, v.y, v.w);
+	GLM_INLINE glm::vec<4, T, P> yyyw(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.y, v.y, v.w);
 	}
 
 	// yyzx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yyzx(const glm::tvec3<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.y, v.z, v.x);
+	GLM_INLINE glm::vec<4, T, P> yyzx(const glm::vec<3, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.y, v.z, v.x);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yyzx(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.y, v.z, v.x);
+	GLM_INLINE glm::vec<4, T, P> yyzx(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.y, v.z, v.x);
 	}
 
 	// yyzy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yyzy(const glm::tvec3<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.y, v.z, v.y);
+	GLM_INLINE glm::vec<4, T, P> yyzy(const glm::vec<3, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.y, v.z, v.y);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yyzy(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.y, v.z, v.y);
+	GLM_INLINE glm::vec<4, T, P> yyzy(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.y, v.z, v.y);
 	}
 
 	// yyzz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yyzz(const glm::tvec3<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.y, v.z, v.z);
+	GLM_INLINE glm::vec<4, T, P> yyzz(const glm::vec<3, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.y, v.z, v.z);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yyzz(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.y, v.z, v.z);
+	GLM_INLINE glm::vec<4, T, P> yyzz(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.y, v.z, v.z);
 	}
 
 	// yyzw
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yyzw(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.y, v.z, v.w);
+	GLM_INLINE glm::vec<4, T, P> yyzw(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.y, v.z, v.w);
 	}
 
 	// yywx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yywx(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.y, v.w, v.x);
+	GLM_INLINE glm::vec<4, T, P> yywx(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.y, v.w, v.x);
 	}
 
 	// yywy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yywy(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.y, v.w, v.y);
+	GLM_INLINE glm::vec<4, T, P> yywy(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.y, v.w, v.y);
 	}
 
 	// yywz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yywz(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.y, v.w, v.z);
+	GLM_INLINE glm::vec<4, T, P> yywz(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.y, v.w, v.z);
 	}
 
 	// yyww
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yyww(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.y, v.w, v.w);
+	GLM_INLINE glm::vec<4, T, P> yyww(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.y, v.w, v.w);
 	}
 
 	// yzxx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yzxx(const glm::tvec3<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.z, v.x, v.x);
+	GLM_INLINE glm::vec<4, T, P> yzxx(const glm::vec<3, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.z, v.x, v.x);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yzxx(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.z, v.x, v.x);
+	GLM_INLINE glm::vec<4, T, P> yzxx(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.z, v.x, v.x);
 	}
 
 	// yzxy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yzxy(const glm::tvec3<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.z, v.x, v.y);
+	GLM_INLINE glm::vec<4, T, P> yzxy(const glm::vec<3, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.z, v.x, v.y);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yzxy(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.z, v.x, v.y);
+	GLM_INLINE glm::vec<4, T, P> yzxy(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.z, v.x, v.y);
 	}
 
 	// yzxz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yzxz(const glm::tvec3<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.z, v.x, v.z);
+	GLM_INLINE glm::vec<4, T, P> yzxz(const glm::vec<3, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.z, v.x, v.z);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yzxz(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.z, v.x, v.z);
+	GLM_INLINE glm::vec<4, T, P> yzxz(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.z, v.x, v.z);
 	}
 
 	// yzxw
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yzxw(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.z, v.x, v.w);
+	GLM_INLINE glm::vec<4, T, P> yzxw(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.z, v.x, v.w);
 	}
 
 	// yzyx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yzyx(const glm::tvec3<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.z, v.y, v.x);
+	GLM_INLINE glm::vec<4, T, P> yzyx(const glm::vec<3, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.z, v.y, v.x);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yzyx(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.z, v.y, v.x);
+	GLM_INLINE glm::vec<4, T, P> yzyx(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.z, v.y, v.x);
 	}
 
 	// yzyy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yzyy(const glm::tvec3<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.z, v.y, v.y);
+	GLM_INLINE glm::vec<4, T, P> yzyy(const glm::vec<3, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.z, v.y, v.y);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yzyy(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.z, v.y, v.y);
+	GLM_INLINE glm::vec<4, T, P> yzyy(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.z, v.y, v.y);
 	}
 
 	// yzyz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yzyz(const glm::tvec3<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.z, v.y, v.z);
+	GLM_INLINE glm::vec<4, T, P> yzyz(const glm::vec<3, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.z, v.y, v.z);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yzyz(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.z, v.y, v.z);
+	GLM_INLINE glm::vec<4, T, P> yzyz(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.z, v.y, v.z);
 	}
 
 	// yzyw
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yzyw(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.z, v.y, v.w);
+	GLM_INLINE glm::vec<4, T, P> yzyw(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.z, v.y, v.w);
 	}
 
 	// yzzx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yzzx(const glm::tvec3<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.z, v.z, v.x);
+	GLM_INLINE glm::vec<4, T, P> yzzx(const glm::vec<3, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.z, v.z, v.x);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yzzx(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.z, v.z, v.x);
+	GLM_INLINE glm::vec<4, T, P> yzzx(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.z, v.z, v.x);
 	}
 
 	// yzzy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yzzy(const glm::tvec3<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.z, v.z, v.y);
+	GLM_INLINE glm::vec<4, T, P> yzzy(const glm::vec<3, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.z, v.z, v.y);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yzzy(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.z, v.z, v.y);
+	GLM_INLINE glm::vec<4, T, P> yzzy(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.z, v.z, v.y);
 	}
 
 	// yzzz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yzzz(const glm::tvec3<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.z, v.z, v.z);
+	GLM_INLINE glm::vec<4, T, P> yzzz(const glm::vec<3, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.z, v.z, v.z);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yzzz(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.z, v.z, v.z);
+	GLM_INLINE glm::vec<4, T, P> yzzz(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.z, v.z, v.z);
 	}
 
 	// yzzw
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yzzw(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.z, v.z, v.w);
+	GLM_INLINE glm::vec<4, T, P> yzzw(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.z, v.z, v.w);
 	}
 
 	// yzwx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yzwx(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.z, v.w, v.x);
+	GLM_INLINE glm::vec<4, T, P> yzwx(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.z, v.w, v.x);
 	}
 
 	// yzwy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yzwy(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.z, v.w, v.y);
+	GLM_INLINE glm::vec<4, T, P> yzwy(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.z, v.w, v.y);
 	}
 
 	// yzwz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yzwz(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.z, v.w, v.z);
+	GLM_INLINE glm::vec<4, T, P> yzwz(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.z, v.w, v.z);
 	}
 
 	// yzww
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> yzww(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.z, v.w, v.w);
+	GLM_INLINE glm::vec<4, T, P> yzww(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.z, v.w, v.w);
 	}
 
 	// ywxx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> ywxx(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.w, v.x, v.x);
+	GLM_INLINE glm::vec<4, T, P> ywxx(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.w, v.x, v.x);
 	}
 
 	// ywxy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> ywxy(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.w, v.x, v.y);
+	GLM_INLINE glm::vec<4, T, P> ywxy(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.w, v.x, v.y);
 	}
 
 	// ywxz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> ywxz(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.w, v.x, v.z);
+	GLM_INLINE glm::vec<4, T, P> ywxz(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.w, v.x, v.z);
 	}
 
 	// ywxw
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> ywxw(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.w, v.x, v.w);
+	GLM_INLINE glm::vec<4, T, P> ywxw(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.w, v.x, v.w);
 	}
 
 	// ywyx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> ywyx(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.w, v.y, v.x);
+	GLM_INLINE glm::vec<4, T, P> ywyx(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.w, v.y, v.x);
 	}
 
 	// ywyy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> ywyy(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.w, v.y, v.y);
+	GLM_INLINE glm::vec<4, T, P> ywyy(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.w, v.y, v.y);
 	}
 
 	// ywyz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> ywyz(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.w, v.y, v.z);
+	GLM_INLINE glm::vec<4, T, P> ywyz(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.w, v.y, v.z);
 	}
 
 	// ywyw
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> ywyw(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.w, v.y, v.w);
+	GLM_INLINE glm::vec<4, T, P> ywyw(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.w, v.y, v.w);
 	}
 
 	// ywzx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> ywzx(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.w, v.z, v.x);
+	GLM_INLINE glm::vec<4, T, P> ywzx(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.w, v.z, v.x);
 	}
 
 	// ywzy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> ywzy(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.w, v.z, v.y);
+	GLM_INLINE glm::vec<4, T, P> ywzy(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.w, v.z, v.y);
 	}
 
 	// ywzz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> ywzz(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.w, v.z, v.z);
+	GLM_INLINE glm::vec<4, T, P> ywzz(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.w, v.z, v.z);
 	}
 
 	// ywzw
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> ywzw(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.w, v.z, v.w);
+	GLM_INLINE glm::vec<4, T, P> ywzw(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.w, v.z, v.w);
 	}
 
 	// ywwx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> ywwx(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.w, v.w, v.x);
+	GLM_INLINE glm::vec<4, T, P> ywwx(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.w, v.w, v.x);
 	}
 
 	// ywwy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> ywwy(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.w, v.w, v.y);
+	GLM_INLINE glm::vec<4, T, P> ywwy(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.w, v.w, v.y);
 	}
 
 	// ywwz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> ywwz(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.w, v.w, v.z);
+	GLM_INLINE glm::vec<4, T, P> ywwz(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.w, v.w, v.z);
 	}
 
 	// ywww
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> ywww(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.y, v.w, v.w, v.w);
+	GLM_INLINE glm::vec<4, T, P> ywww(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.y, v.w, v.w, v.w);
 	}
 
 	// zxxx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zxxx(const glm::tvec3<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.x, v.x, v.x);
+	GLM_INLINE glm::vec<4, T, P> zxxx(const glm::vec<3, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.x, v.x, v.x);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zxxx(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.x, v.x, v.x);
+	GLM_INLINE glm::vec<4, T, P> zxxx(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.x, v.x, v.x);
 	}
 
 	// zxxy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zxxy(const glm::tvec3<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.x, v.x, v.y);
+	GLM_INLINE glm::vec<4, T, P> zxxy(const glm::vec<3, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.x, v.x, v.y);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zxxy(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.x, v.x, v.y);
+	GLM_INLINE glm::vec<4, T, P> zxxy(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.x, v.x, v.y);
 	}
 
 	// zxxz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zxxz(const glm::tvec3<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.x, v.x, v.z);
+	GLM_INLINE glm::vec<4, T, P> zxxz(const glm::vec<3, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.x, v.x, v.z);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zxxz(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.x, v.x, v.z);
+	GLM_INLINE glm::vec<4, T, P> zxxz(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.x, v.x, v.z);
 	}
 
 	// zxxw
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zxxw(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.x, v.x, v.w);
+	GLM_INLINE glm::vec<4, T, P> zxxw(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.x, v.x, v.w);
 	}
 
 	// zxyx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zxyx(const glm::tvec3<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.x, v.y, v.x);
+	GLM_INLINE glm::vec<4, T, P> zxyx(const glm::vec<3, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.x, v.y, v.x);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zxyx(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.x, v.y, v.x);
+	GLM_INLINE glm::vec<4, T, P> zxyx(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.x, v.y, v.x);
 	}
 
 	// zxyy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zxyy(const glm::tvec3<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.x, v.y, v.y);
+	GLM_INLINE glm::vec<4, T, P> zxyy(const glm::vec<3, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.x, v.y, v.y);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zxyy(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.x, v.y, v.y);
+	GLM_INLINE glm::vec<4, T, P> zxyy(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.x, v.y, v.y);
 	}
 
 	// zxyz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zxyz(const glm::tvec3<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.x, v.y, v.z);
+	GLM_INLINE glm::vec<4, T, P> zxyz(const glm::vec<3, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.x, v.y, v.z);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zxyz(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.x, v.y, v.z);
+	GLM_INLINE glm::vec<4, T, P> zxyz(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.x, v.y, v.z);
 	}
 
 	// zxyw
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zxyw(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.x, v.y, v.w);
+	GLM_INLINE glm::vec<4, T, P> zxyw(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.x, v.y, v.w);
 	}
 
 	// zxzx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zxzx(const glm::tvec3<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.x, v.z, v.x);
+	GLM_INLINE glm::vec<4, T, P> zxzx(const glm::vec<3, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.x, v.z, v.x);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zxzx(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.x, v.z, v.x);
+	GLM_INLINE glm::vec<4, T, P> zxzx(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.x, v.z, v.x);
 	}
 
 	// zxzy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zxzy(const glm::tvec3<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.x, v.z, v.y);
+	GLM_INLINE glm::vec<4, T, P> zxzy(const glm::vec<3, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.x, v.z, v.y);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zxzy(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.x, v.z, v.y);
+	GLM_INLINE glm::vec<4, T, P> zxzy(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.x, v.z, v.y);
 	}
 
 	// zxzz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zxzz(const glm::tvec3<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.x, v.z, v.z);
+	GLM_INLINE glm::vec<4, T, P> zxzz(const glm::vec<3, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.x, v.z, v.z);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zxzz(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.x, v.z, v.z);
+	GLM_INLINE glm::vec<4, T, P> zxzz(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.x, v.z, v.z);
 	}
 
 	// zxzw
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zxzw(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.x, v.z, v.w);
+	GLM_INLINE glm::vec<4, T, P> zxzw(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.x, v.z, v.w);
 	}
 
 	// zxwx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zxwx(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.x, v.w, v.x);
+	GLM_INLINE glm::vec<4, T, P> zxwx(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.x, v.w, v.x);
 	}
 
 	// zxwy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zxwy(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.x, v.w, v.y);
+	GLM_INLINE glm::vec<4, T, P> zxwy(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.x, v.w, v.y);
 	}
 
 	// zxwz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zxwz(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.x, v.w, v.z);
+	GLM_INLINE glm::vec<4, T, P> zxwz(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.x, v.w, v.z);
 	}
 
 	// zxww
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zxww(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.x, v.w, v.w);
+	GLM_INLINE glm::vec<4, T, P> zxww(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.x, v.w, v.w);
 	}
 
 	// zyxx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zyxx(const glm::tvec3<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.y, v.x, v.x);
+	GLM_INLINE glm::vec<4, T, P> zyxx(const glm::vec<3, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.y, v.x, v.x);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zyxx(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.y, v.x, v.x);
+	GLM_INLINE glm::vec<4, T, P> zyxx(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.y, v.x, v.x);
 	}
 
 	// zyxy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zyxy(const glm::tvec3<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.y, v.x, v.y);
+	GLM_INLINE glm::vec<4, T, P> zyxy(const glm::vec<3, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.y, v.x, v.y);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zyxy(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.y, v.x, v.y);
+	GLM_INLINE glm::vec<4, T, P> zyxy(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.y, v.x, v.y);
 	}
 
 	// zyxz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zyxz(const glm::tvec3<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.y, v.x, v.z);
+	GLM_INLINE glm::vec<4, T, P> zyxz(const glm::vec<3, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.y, v.x, v.z);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zyxz(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.y, v.x, v.z);
+	GLM_INLINE glm::vec<4, T, P> zyxz(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.y, v.x, v.z);
 	}
 
 	// zyxw
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zyxw(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.y, v.x, v.w);
+	GLM_INLINE glm::vec<4, T, P> zyxw(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.y, v.x, v.w);
 	}
 
 	// zyyx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zyyx(const glm::tvec3<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.y, v.y, v.x);
+	GLM_INLINE glm::vec<4, T, P> zyyx(const glm::vec<3, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.y, v.y, v.x);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zyyx(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.y, v.y, v.x);
+	GLM_INLINE glm::vec<4, T, P> zyyx(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.y, v.y, v.x);
 	}
 
 	// zyyy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zyyy(const glm::tvec3<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.y, v.y, v.y);
+	GLM_INLINE glm::vec<4, T, P> zyyy(const glm::vec<3, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.y, v.y, v.y);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zyyy(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.y, v.y, v.y);
+	GLM_INLINE glm::vec<4, T, P> zyyy(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.y, v.y, v.y);
 	}
 
 	// zyyz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zyyz(const glm::tvec3<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.y, v.y, v.z);
+	GLM_INLINE glm::vec<4, T, P> zyyz(const glm::vec<3, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.y, v.y, v.z);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zyyz(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.y, v.y, v.z);
+	GLM_INLINE glm::vec<4, T, P> zyyz(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.y, v.y, v.z);
 	}
 
 	// zyyw
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zyyw(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.y, v.y, v.w);
+	GLM_INLINE glm::vec<4, T, P> zyyw(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.y, v.y, v.w);
 	}
 
 	// zyzx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zyzx(const glm::tvec3<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.y, v.z, v.x);
+	GLM_INLINE glm::vec<4, T, P> zyzx(const glm::vec<3, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.y, v.z, v.x);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zyzx(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.y, v.z, v.x);
+	GLM_INLINE glm::vec<4, T, P> zyzx(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.y, v.z, v.x);
 	}
 
 	// zyzy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zyzy(const glm::tvec3<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.y, v.z, v.y);
+	GLM_INLINE glm::vec<4, T, P> zyzy(const glm::vec<3, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.y, v.z, v.y);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zyzy(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.y, v.z, v.y);
+	GLM_INLINE glm::vec<4, T, P> zyzy(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.y, v.z, v.y);
 	}
 
 	// zyzz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zyzz(const glm::tvec3<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.y, v.z, v.z);
+	GLM_INLINE glm::vec<4, T, P> zyzz(const glm::vec<3, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.y, v.z, v.z);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zyzz(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.y, v.z, v.z);
+	GLM_INLINE glm::vec<4, T, P> zyzz(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.y, v.z, v.z);
 	}
 
 	// zyzw
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zyzw(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.y, v.z, v.w);
+	GLM_INLINE glm::vec<4, T, P> zyzw(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.y, v.z, v.w);
 	}
 
 	// zywx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zywx(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.y, v.w, v.x);
+	GLM_INLINE glm::vec<4, T, P> zywx(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.y, v.w, v.x);
 	}
 
 	// zywy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zywy(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.y, v.w, v.y);
+	GLM_INLINE glm::vec<4, T, P> zywy(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.y, v.w, v.y);
 	}
 
 	// zywz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zywz(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.y, v.w, v.z);
+	GLM_INLINE glm::vec<4, T, P> zywz(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.y, v.w, v.z);
 	}
 
 	// zyww
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zyww(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.y, v.w, v.w);
+	GLM_INLINE glm::vec<4, T, P> zyww(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.y, v.w, v.w);
 	}
 
 	// zzxx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zzxx(const glm::tvec3<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.z, v.x, v.x);
+	GLM_INLINE glm::vec<4, T, P> zzxx(const glm::vec<3, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.z, v.x, v.x);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zzxx(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.z, v.x, v.x);
+	GLM_INLINE glm::vec<4, T, P> zzxx(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.z, v.x, v.x);
 	}
 
 	// zzxy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zzxy(const glm::tvec3<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.z, v.x, v.y);
+	GLM_INLINE glm::vec<4, T, P> zzxy(const glm::vec<3, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.z, v.x, v.y);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zzxy(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.z, v.x, v.y);
+	GLM_INLINE glm::vec<4, T, P> zzxy(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.z, v.x, v.y);
 	}
 
 	// zzxz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zzxz(const glm::tvec3<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.z, v.x, v.z);
+	GLM_INLINE glm::vec<4, T, P> zzxz(const glm::vec<3, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.z, v.x, v.z);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zzxz(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.z, v.x, v.z);
+	GLM_INLINE glm::vec<4, T, P> zzxz(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.z, v.x, v.z);
 	}
 
 	// zzxw
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zzxw(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.z, v.x, v.w);
+	GLM_INLINE glm::vec<4, T, P> zzxw(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.z, v.x, v.w);
 	}
 
 	// zzyx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zzyx(const glm::tvec3<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.z, v.y, v.x);
+	GLM_INLINE glm::vec<4, T, P> zzyx(const glm::vec<3, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.z, v.y, v.x);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zzyx(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.z, v.y, v.x);
+	GLM_INLINE glm::vec<4, T, P> zzyx(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.z, v.y, v.x);
 	}
 
 	// zzyy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zzyy(const glm::tvec3<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.z, v.y, v.y);
+	GLM_INLINE glm::vec<4, T, P> zzyy(const glm::vec<3, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.z, v.y, v.y);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zzyy(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.z, v.y, v.y);
+	GLM_INLINE glm::vec<4, T, P> zzyy(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.z, v.y, v.y);
 	}
 
 	// zzyz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zzyz(const glm::tvec3<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.z, v.y, v.z);
+	GLM_INLINE glm::vec<4, T, P> zzyz(const glm::vec<3, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.z, v.y, v.z);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zzyz(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.z, v.y, v.z);
+	GLM_INLINE glm::vec<4, T, P> zzyz(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.z, v.y, v.z);
 	}
 
 	// zzyw
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zzyw(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.z, v.y, v.w);
+	GLM_INLINE glm::vec<4, T, P> zzyw(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.z, v.y, v.w);
 	}
 
 	// zzzx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zzzx(const glm::tvec3<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.z, v.z, v.x);
+	GLM_INLINE glm::vec<4, T, P> zzzx(const glm::vec<3, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.z, v.z, v.x);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zzzx(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.z, v.z, v.x);
+	GLM_INLINE glm::vec<4, T, P> zzzx(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.z, v.z, v.x);
 	}
 
 	// zzzy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zzzy(const glm::tvec3<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.z, v.z, v.y);
+	GLM_INLINE glm::vec<4, T, P> zzzy(const glm::vec<3, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.z, v.z, v.y);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zzzy(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.z, v.z, v.y);
+	GLM_INLINE glm::vec<4, T, P> zzzy(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.z, v.z, v.y);
 	}
 
 	// zzzz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zzzz(const glm::tvec3<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.z, v.z, v.z);
+	GLM_INLINE glm::vec<4, T, P> zzzz(const glm::vec<3, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.z, v.z, v.z);
 	}
 
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zzzz(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.z, v.z, v.z);
+	GLM_INLINE glm::vec<4, T, P> zzzz(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.z, v.z, v.z);
 	}
 
 	// zzzw
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zzzw(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.z, v.z, v.w);
+	GLM_INLINE glm::vec<4, T, P> zzzw(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.z, v.z, v.w);
 	}
 
 	// zzwx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zzwx(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.z, v.w, v.x);
+	GLM_INLINE glm::vec<4, T, P> zzwx(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.z, v.w, v.x);
 	}
 
 	// zzwy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zzwy(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.z, v.w, v.y);
+	GLM_INLINE glm::vec<4, T, P> zzwy(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.z, v.w, v.y);
 	}
 
 	// zzwz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zzwz(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.z, v.w, v.z);
+	GLM_INLINE glm::vec<4, T, P> zzwz(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.z, v.w, v.z);
 	}
 
 	// zzww
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zzww(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.z, v.w, v.w);
+	GLM_INLINE glm::vec<4, T, P> zzww(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.z, v.w, v.w);
 	}
 
 	// zwxx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zwxx(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.w, v.x, v.x);
+	GLM_INLINE glm::vec<4, T, P> zwxx(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.w, v.x, v.x);
 	}
 
 	// zwxy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zwxy(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.w, v.x, v.y);
+	GLM_INLINE glm::vec<4, T, P> zwxy(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.w, v.x, v.y);
 	}
 
 	// zwxz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zwxz(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.w, v.x, v.z);
+	GLM_INLINE glm::vec<4, T, P> zwxz(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.w, v.x, v.z);
 	}
 
 	// zwxw
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zwxw(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.w, v.x, v.w);
+	GLM_INLINE glm::vec<4, T, P> zwxw(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.w, v.x, v.w);
 	}
 
 	// zwyx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zwyx(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.w, v.y, v.x);
+	GLM_INLINE glm::vec<4, T, P> zwyx(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.w, v.y, v.x);
 	}
 
 	// zwyy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zwyy(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.w, v.y, v.y);
+	GLM_INLINE glm::vec<4, T, P> zwyy(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.w, v.y, v.y);
 	}
 
 	// zwyz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zwyz(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.w, v.y, v.z);
+	GLM_INLINE glm::vec<4, T, P> zwyz(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.w, v.y, v.z);
 	}
 
 	// zwyw
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zwyw(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.w, v.y, v.w);
+	GLM_INLINE glm::vec<4, T, P> zwyw(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.w, v.y, v.w);
 	}
 
 	// zwzx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zwzx(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.w, v.z, v.x);
+	GLM_INLINE glm::vec<4, T, P> zwzx(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.w, v.z, v.x);
 	}
 
 	// zwzy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zwzy(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.w, v.z, v.y);
+	GLM_INLINE glm::vec<4, T, P> zwzy(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.w, v.z, v.y);
 	}
 
 	// zwzz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zwzz(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.w, v.z, v.z);
+	GLM_INLINE glm::vec<4, T, P> zwzz(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.w, v.z, v.z);
 	}
 
 	// zwzw
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zwzw(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.w, v.z, v.w);
+	GLM_INLINE glm::vec<4, T, P> zwzw(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.w, v.z, v.w);
 	}
 
 	// zwwx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zwwx(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.w, v.w, v.x);
+	GLM_INLINE glm::vec<4, T, P> zwwx(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.w, v.w, v.x);
 	}
 
 	// zwwy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zwwy(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.w, v.w, v.y);
+	GLM_INLINE glm::vec<4, T, P> zwwy(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.w, v.w, v.y);
 	}
 
 	// zwwz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zwwz(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.w, v.w, v.z);
+	GLM_INLINE glm::vec<4, T, P> zwwz(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.w, v.w, v.z);
 	}
 
 	// zwww
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> zwww(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.z, v.w, v.w, v.w);
+	GLM_INLINE glm::vec<4, T, P> zwww(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.z, v.w, v.w, v.w);
 	}
 
 	// wxxx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> wxxx(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.w, v.x, v.x, v.x);
+	GLM_INLINE glm::vec<4, T, P> wxxx(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.w, v.x, v.x, v.x);
 	}
 
 	// wxxy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> wxxy(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.w, v.x, v.x, v.y);
+	GLM_INLINE glm::vec<4, T, P> wxxy(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.w, v.x, v.x, v.y);
 	}
 
 	// wxxz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> wxxz(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.w, v.x, v.x, v.z);
+	GLM_INLINE glm::vec<4, T, P> wxxz(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.w, v.x, v.x, v.z);
 	}
 
 	// wxxw
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> wxxw(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.w, v.x, v.x, v.w);
+	GLM_INLINE glm::vec<4, T, P> wxxw(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.w, v.x, v.x, v.w);
 	}
 
 	// wxyx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> wxyx(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.w, v.x, v.y, v.x);
+	GLM_INLINE glm::vec<4, T, P> wxyx(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.w, v.x, v.y, v.x);
 	}
 
 	// wxyy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> wxyy(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.w, v.x, v.y, v.y);
+	GLM_INLINE glm::vec<4, T, P> wxyy(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.w, v.x, v.y, v.y);
 	}
 
 	// wxyz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> wxyz(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.w, v.x, v.y, v.z);
+	GLM_INLINE glm::vec<4, T, P> wxyz(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.w, v.x, v.y, v.z);
 	}
 
 	// wxyw
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> wxyw(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.w, v.x, v.y, v.w);
+	GLM_INLINE glm::vec<4, T, P> wxyw(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.w, v.x, v.y, v.w);
 	}
 
 	// wxzx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> wxzx(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.w, v.x, v.z, v.x);
+	GLM_INLINE glm::vec<4, T, P> wxzx(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.w, v.x, v.z, v.x);
 	}
 
 	// wxzy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> wxzy(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.w, v.x, v.z, v.y);
+	GLM_INLINE glm::vec<4, T, P> wxzy(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.w, v.x, v.z, v.y);
 	}
 
 	// wxzz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> wxzz(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.w, v.x, v.z, v.z);
+	GLM_INLINE glm::vec<4, T, P> wxzz(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.w, v.x, v.z, v.z);
 	}
 
 	// wxzw
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> wxzw(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.w, v.x, v.z, v.w);
+	GLM_INLINE glm::vec<4, T, P> wxzw(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.w, v.x, v.z, v.w);
 	}
 
 	// wxwx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> wxwx(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.w, v.x, v.w, v.x);
+	GLM_INLINE glm::vec<4, T, P> wxwx(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.w, v.x, v.w, v.x);
 	}
 
 	// wxwy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> wxwy(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.w, v.x, v.w, v.y);
+	GLM_INLINE glm::vec<4, T, P> wxwy(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.w, v.x, v.w, v.y);
 	}
 
 	// wxwz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> wxwz(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.w, v.x, v.w, v.z);
+	GLM_INLINE glm::vec<4, T, P> wxwz(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.w, v.x, v.w, v.z);
 	}
 
 	// wxww
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> wxww(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.w, v.x, v.w, v.w);
+	GLM_INLINE glm::vec<4, T, P> wxww(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.w, v.x, v.w, v.w);
 	}
 
 	// wyxx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> wyxx(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.w, v.y, v.x, v.x);
+	GLM_INLINE glm::vec<4, T, P> wyxx(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.w, v.y, v.x, v.x);
 	}
 
 	// wyxy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> wyxy(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.w, v.y, v.x, v.y);
+	GLM_INLINE glm::vec<4, T, P> wyxy(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.w, v.y, v.x, v.y);
 	}
 
 	// wyxz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> wyxz(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.w, v.y, v.x, v.z);
+	GLM_INLINE glm::vec<4, T, P> wyxz(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.w, v.y, v.x, v.z);
 	}
 
 	// wyxw
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> wyxw(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.w, v.y, v.x, v.w);
+	GLM_INLINE glm::vec<4, T, P> wyxw(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.w, v.y, v.x, v.w);
 	}
 
 	// wyyx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> wyyx(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.w, v.y, v.y, v.x);
+	GLM_INLINE glm::vec<4, T, P> wyyx(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.w, v.y, v.y, v.x);
 	}
 
 	// wyyy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> wyyy(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.w, v.y, v.y, v.y);
+	GLM_INLINE glm::vec<4, T, P> wyyy(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.w, v.y, v.y, v.y);
 	}
 
 	// wyyz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> wyyz(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.w, v.y, v.y, v.z);
+	GLM_INLINE glm::vec<4, T, P> wyyz(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.w, v.y, v.y, v.z);
 	}
 
 	// wyyw
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> wyyw(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.w, v.y, v.y, v.w);
+	GLM_INLINE glm::vec<4, T, P> wyyw(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.w, v.y, v.y, v.w);
 	}
 
 	// wyzx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> wyzx(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.w, v.y, v.z, v.x);
+	GLM_INLINE glm::vec<4, T, P> wyzx(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.w, v.y, v.z, v.x);
 	}
 
 	// wyzy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> wyzy(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.w, v.y, v.z, v.y);
+	GLM_INLINE glm::vec<4, T, P> wyzy(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.w, v.y, v.z, v.y);
 	}
 
 	// wyzz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> wyzz(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.w, v.y, v.z, v.z);
+	GLM_INLINE glm::vec<4, T, P> wyzz(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.w, v.y, v.z, v.z);
 	}
 
 	// wyzw
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> wyzw(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.w, v.y, v.z, v.w);
+	GLM_INLINE glm::vec<4, T, P> wyzw(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.w, v.y, v.z, v.w);
 	}
 
 	// wywx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> wywx(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.w, v.y, v.w, v.x);
+	GLM_INLINE glm::vec<4, T, P> wywx(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.w, v.y, v.w, v.x);
 	}
 
 	// wywy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> wywy(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.w, v.y, v.w, v.y);
+	GLM_INLINE glm::vec<4, T, P> wywy(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.w, v.y, v.w, v.y);
 	}
 
 	// wywz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> wywz(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.w, v.y, v.w, v.z);
+	GLM_INLINE glm::vec<4, T, P> wywz(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.w, v.y, v.w, v.z);
 	}
 
 	// wyww
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> wyww(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.w, v.y, v.w, v.w);
+	GLM_INLINE glm::vec<4, T, P> wyww(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.w, v.y, v.w, v.w);
 	}
 
 	// wzxx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> wzxx(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.w, v.z, v.x, v.x);
+	GLM_INLINE glm::vec<4, T, P> wzxx(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.w, v.z, v.x, v.x);
 	}
 
 	// wzxy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> wzxy(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.w, v.z, v.x, v.y);
+	GLM_INLINE glm::vec<4, T, P> wzxy(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.w, v.z, v.x, v.y);
 	}
 
 	// wzxz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> wzxz(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.w, v.z, v.x, v.z);
+	GLM_INLINE glm::vec<4, T, P> wzxz(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.w, v.z, v.x, v.z);
 	}
 
 	// wzxw
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> wzxw(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.w, v.z, v.x, v.w);
+	GLM_INLINE glm::vec<4, T, P> wzxw(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.w, v.z, v.x, v.w);
 	}
 
 	// wzyx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> wzyx(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.w, v.z, v.y, v.x);
+	GLM_INLINE glm::vec<4, T, P> wzyx(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.w, v.z, v.y, v.x);
 	}
 
 	// wzyy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> wzyy(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.w, v.z, v.y, v.y);
+	GLM_INLINE glm::vec<4, T, P> wzyy(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.w, v.z, v.y, v.y);
 	}
 
 	// wzyz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> wzyz(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.w, v.z, v.y, v.z);
+	GLM_INLINE glm::vec<4, T, P> wzyz(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.w, v.z, v.y, v.z);
 	}
 
 	// wzyw
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> wzyw(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.w, v.z, v.y, v.w);
+	GLM_INLINE glm::vec<4, T, P> wzyw(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.w, v.z, v.y, v.w);
 	}
 
 	// wzzx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> wzzx(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.w, v.z, v.z, v.x);
+	GLM_INLINE glm::vec<4, T, P> wzzx(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.w, v.z, v.z, v.x);
 	}
 
 	// wzzy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> wzzy(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.w, v.z, v.z, v.y);
+	GLM_INLINE glm::vec<4, T, P> wzzy(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.w, v.z, v.z, v.y);
 	}
 
 	// wzzz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> wzzz(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.w, v.z, v.z, v.z);
+	GLM_INLINE glm::vec<4, T, P> wzzz(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.w, v.z, v.z, v.z);
 	}
 
 	// wzzw
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> wzzw(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.w, v.z, v.z, v.w);
+	GLM_INLINE glm::vec<4, T, P> wzzw(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.w, v.z, v.z, v.w);
 	}
 
 	// wzwx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> wzwx(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.w, v.z, v.w, v.x);
+	GLM_INLINE glm::vec<4, T, P> wzwx(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.w, v.z, v.w, v.x);
 	}
 
 	// wzwy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> wzwy(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.w, v.z, v.w, v.y);
+	GLM_INLINE glm::vec<4, T, P> wzwy(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.w, v.z, v.w, v.y);
 	}
 
 	// wzwz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> wzwz(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.w, v.z, v.w, v.z);
+	GLM_INLINE glm::vec<4, T, P> wzwz(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.w, v.z, v.w, v.z);
 	}
 
 	// wzww
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> wzww(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.w, v.z, v.w, v.w);
+	GLM_INLINE glm::vec<4, T, P> wzww(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.w, v.z, v.w, v.w);
 	}
 
 	// wwxx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> wwxx(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.w, v.w, v.x, v.x);
+	GLM_INLINE glm::vec<4, T, P> wwxx(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.w, v.w, v.x, v.x);
 	}
 
 	// wwxy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> wwxy(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.w, v.w, v.x, v.y);
+	GLM_INLINE glm::vec<4, T, P> wwxy(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.w, v.w, v.x, v.y);
 	}
 
 	// wwxz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> wwxz(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.w, v.w, v.x, v.z);
+	GLM_INLINE glm::vec<4, T, P> wwxz(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.w, v.w, v.x, v.z);
 	}
 
 	// wwxw
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> wwxw(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.w, v.w, v.x, v.w);
+	GLM_INLINE glm::vec<4, T, P> wwxw(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.w, v.w, v.x, v.w);
 	}
 
 	// wwyx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> wwyx(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.w, v.w, v.y, v.x);
+	GLM_INLINE glm::vec<4, T, P> wwyx(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.w, v.w, v.y, v.x);
 	}
 
 	// wwyy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> wwyy(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.w, v.w, v.y, v.y);
+	GLM_INLINE glm::vec<4, T, P> wwyy(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.w, v.w, v.y, v.y);
 	}
 
 	// wwyz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> wwyz(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.w, v.w, v.y, v.z);
+	GLM_INLINE glm::vec<4, T, P> wwyz(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.w, v.w, v.y, v.z);
 	}
 
 	// wwyw
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> wwyw(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.w, v.w, v.y, v.w);
+	GLM_INLINE glm::vec<4, T, P> wwyw(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.w, v.w, v.y, v.w);
 	}
 
 	// wwzx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> wwzx(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.w, v.w, v.z, v.x);
+	GLM_INLINE glm::vec<4, T, P> wwzx(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.w, v.w, v.z, v.x);
 	}
 
 	// wwzy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> wwzy(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.w, v.w, v.z, v.y);
+	GLM_INLINE glm::vec<4, T, P> wwzy(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.w, v.w, v.z, v.y);
 	}
 
 	// wwzz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> wwzz(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.w, v.w, v.z, v.z);
+	GLM_INLINE glm::vec<4, T, P> wwzz(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.w, v.w, v.z, v.z);
 	}
 
 	// wwzw
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> wwzw(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.w, v.w, v.z, v.w);
+	GLM_INLINE glm::vec<4, T, P> wwzw(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.w, v.w, v.z, v.w);
 	}
 
 	// wwwx
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> wwwx(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.w, v.w, v.w, v.x);
+	GLM_INLINE glm::vec<4, T, P> wwwx(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.w, v.w, v.w, v.x);
 	}
 
 	// wwwy
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> wwwy(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.w, v.w, v.w, v.y);
+	GLM_INLINE glm::vec<4, T, P> wwwy(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.w, v.w, v.w, v.y);
 	}
 
 	// wwwz
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> wwwz(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.w, v.w, v.w, v.z);
+	GLM_INLINE glm::vec<4, T, P> wwwz(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.w, v.w, v.w, v.z);
 	}
 
 	// wwww
 	template<typename T, precision P>
-	GLM_INLINE glm::tvec4<T, P> wwww(const glm::tvec4<T, P> &v) {
-		return glm::tvec4<T, P>(v.w, v.w, v.w, v.w);
+	GLM_INLINE glm::vec<4, T, P> wwww(const glm::vec<4, T, P> &v) {
+		return glm::vec<4, T, P>(v.w, v.w, v.w, v.w);
 	}
 
 }
diff --git a/glm/gtx/vector_angle.hpp b/glm/gtx/vector_angle.hpp
index a2284746..276da7e8 100644
--- a/glm/gtx/vector_angle.hpp
+++ b/glm/gtx/vector_angle.hpp
@@ -36,7 +36,7 @@ namespace glm
 	//! Returns the absolute angle between two vectors.
 	//! Parameters need to be normalized.
 	/// @see gtx_vector_angle extension.
-	template <typename vecType>
+	template<typename vecType>
 	GLM_FUNC_DECL typename vecType::value_type angle(
 		vecType const & x, 
 		vecType const & y);
@@ -44,19 +44,19 @@ namespace glm
 	//! Returns the oriented angle between two 2d vectors.
 	//! Parameters need to be normalized.
 	/// @see gtx_vector_angle extension.
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_DECL T orientedAngle(
-		tvec2<T, P> const & x,
-		tvec2<T, P> const & y);
+		vec<2, T, P> const & x,
+		vec<2, T, P> const & y);
 
 	//! Returns the oriented angle between two 3d vectors based from a reference axis.
 	//! Parameters need to be normalized.
 	/// @see gtx_vector_angle extension.
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_DECL T orientedAngle(
-		tvec3<T, P> const & x,
-		tvec3<T, P> const & y,
-		tvec3<T, P> const & ref);
+		vec<3, T, P> const & x,
+		vec<3, T, P> const & y,
+		vec<3, T, P> const & ref);
 
 	/// @}
 }// namespace glm
diff --git a/glm/gtx/vector_angle.inl b/glm/gtx/vector_angle.inl
index 05c30285..af99344a 100644
--- a/glm/gtx/vector_angle.inl
+++ b/glm/gtx/vector_angle.inl
@@ -3,7 +3,7 @@
 
 namespace glm
 {
-	template <typename genType> 
+	template<typename genType> 
 	GLM_FUNC_QUALIFIER genType angle
 	(
 		genType const & x,
@@ -14,11 +14,11 @@ namespace glm
 		return acos(clamp(dot(x, y), genType(-1), genType(1)));
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType> 
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
 	GLM_FUNC_QUALIFIER T angle
 	(
-		vecType<T, P> const & x,
-		vecType<T, P> const & y
+		vecType<L, T, P> const& x,
+		vecType<L, T, P> const& y
 	)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'angle' only accept floating-point inputs");
@@ -26,11 +26,11 @@ namespace glm
 	}
 
 	//! \todo epsilon is hard coded to 0.01
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER T orientedAngle
 	(
-		tvec2<T, P> const & x,
-		tvec2<T, P> const & y
+		vec<2, T, P> const & x,
+		vec<2, T, P> const & y
 	)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'orientedAngle' only accept floating-point inputs");
@@ -42,12 +42,12 @@ namespace glm
 			return -Angle;
 	}
 
-	template <typename T, precision P>
+	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER T orientedAngle
 	(
-		tvec3<T, P> const & x,
-		tvec3<T, P> const & y,
-		tvec3<T, P> const & ref
+		vec<3, T, P> const & x,
+		vec<3, T, P> const & y,
+		vec<3, T, P> const & ref
 	)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'orientedAngle' only accept floating-point inputs");
diff --git a/glm/gtx/vector_query.hpp b/glm/gtx/vector_query.hpp
index b92cc4f1..80bbcea1 100644
--- a/glm/gtx/vector_query.hpp
+++ b/glm/gtx/vector_query.hpp
@@ -32,33 +32,33 @@ namespace glm
 
 	//! Check whether two vectors are collinears.
 	/// @see gtx_vector_query extensions.
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL bool areCollinear(vecType<T, P> const & v0, vecType<T, P> const & v1, T const & epsilon);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL bool areCollinear(vecType<L, T, P> const & v0, vecType<L, T, P> const & v1, T const & epsilon);
 		
 	//! Check whether two vectors are orthogonals.
 	/// @see gtx_vector_query extensions.
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL bool areOrthogonal(vecType<T, P> const & v0, vecType<T, P> const & v1, T const & epsilon);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL bool areOrthogonal(vecType<L, T, P> const & v0, vecType<L, T, P> const & v1, T const & epsilon);
 
 	//! Check whether a vector is normalized.
 	/// @see gtx_vector_query extensions.
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL bool isNormalized(vecType<T, P> const & v, T const & epsilon);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL bool isNormalized(vecType<L, T, P> const & v, T const & epsilon);
 		
 	//! Check whether a vector is null.
 	/// @see gtx_vector_query extensions.
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL bool isNull(vecType<T, P> const & v, T const & epsilon);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL bool isNull(vecType<L, T, P> const & v, T const & epsilon);
 
 	//! Check whether a each component of a vector is null.
 	/// @see gtx_vector_query extensions.
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<bool, P> isCompNull(vecType<T, P> const & v, T const & epsilon);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<L, bool, P> isCompNull(vecType<L, T, P> const & v, T const & epsilon);
 
 	//! Check whether two vectors are orthonormal.
 	/// @see gtx_vector_query extensions.
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL bool areOrthonormal(vecType<T, P> const & v0, vecType<T, P> const & v1, T const & epsilon);
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_DECL bool areOrthonormal(vecType<L, T, P> const & v0, vecType<L, T, P> const & v1, T const & epsilon);
 
 	/// @}
 }// namespace glm
diff --git a/glm/gtx/vector_query.inl b/glm/gtx/vector_query.inl
index 85ea5e58..6fa84db2 100644
--- a/glm/gtx/vector_query.inl
+++ b/glm/gtx/vector_query.inl
@@ -6,68 +6,68 @@
 namespace glm{
 namespace detail
 {
-	template <typename T, precision P, template <typename, precision> class vecType>
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
 	struct compute_areCollinear{};
 
-	template <typename T, precision P>
-	struct compute_areCollinear<T, P, tvec2>
+	template<typename T, precision P>
+	struct compute_areCollinear<2, T, P, vec>
 	{
-		GLM_FUNC_QUALIFIER static bool call(tvec2<T, P> const & v0, tvec2<T, P> const & v1, T const & epsilon)
+		GLM_FUNC_QUALIFIER static bool call(vec<2, T, P> const & v0, vec<2, T, P> const & v1, T const & epsilon)
 		{
-			return length(cross(tvec3<T, P>(v0, static_cast<T>(0)), tvec3<T, P>(v1, static_cast<T>(0)))) < epsilon;
+			return length(cross(vec<3, T, P>(v0, static_cast<T>(0)), vec<3, T, P>(v1, static_cast<T>(0)))) < epsilon;
 		}
 	};
 
-	template <typename T, precision P>
-	struct compute_areCollinear<T, P, tvec3>
+	template<typename T, precision P>
+	struct compute_areCollinear<3, T, P, vec>
 	{
-		GLM_FUNC_QUALIFIER static bool call(tvec3<T, P> const & v0, tvec3<T, P> const & v1, T const & epsilon)
+		GLM_FUNC_QUALIFIER static bool call(vec<3, T, P> const & v0, vec<3, T, P> const & v1, T const & epsilon)
 		{
 			return length(cross(v0, v1)) < epsilon;
 		}
 	};
 
-	template <typename T, precision P>
-	struct compute_areCollinear<T, P, tvec4>
+	template<typename T, precision P>
+	struct compute_areCollinear<4, T, P, vec>
 	{
-		GLM_FUNC_QUALIFIER static bool call(tvec4<T, P> const & v0, tvec4<T, P> const & v1, T const & epsilon)
+		GLM_FUNC_QUALIFIER static bool call(vec<4, T, P> const & v0, vec<4, T, P> const & v1, T const & epsilon)
 		{
-			return length(cross(tvec3<T, P>(v0), tvec3<T, P>(v1))) < epsilon;
+			return length(cross(vec<3, T, P>(v0), vec<3, T, P>(v1))) < epsilon;
 		}
 	};
 
-	template <typename T, precision P, template <typename, precision> class vecType>
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
 	struct compute_isCompNull{};
 
-	template <typename T, precision P>
-	struct compute_isCompNull<T, P, tvec2>
+	template<typename T, precision P>
+	struct compute_isCompNull<2, T, P, vec>
 	{
-		GLM_FUNC_QUALIFIER static tvec2<bool, P> call(tvec2<T, P> const & v, T const & epsilon)
+		GLM_FUNC_QUALIFIER static vec<2, bool, P> call(vec<2, T, P> const & v, T const & epsilon)
 		{
-			return tvec2<bool, P>(
+			return vec<2, bool, P>(
 				(abs(v.x) < epsilon),
 				(abs(v.y) < epsilon));
 		}
 	};
 
-	template <typename T, precision P>
-	struct compute_isCompNull<T, P, tvec3>
+	template<typename T, precision P>
+	struct compute_isCompNull<3, T, P, vec>
 	{
-		GLM_FUNC_QUALIFIER static tvec3<bool, P> call(tvec3<T, P> const & v, T const & epsilon)
+		GLM_FUNC_QUALIFIER static vec<3, bool, P> call(vec<3, T, P> const & v, T const & epsilon)
 		{
-			return tvec3<bool, P>(
+			return vec<3, bool, P>(
 				(abs(v.x) < epsilon),
 				(abs(v.y) < epsilon),
 				(abs(v.z) < epsilon));
 		}
 	};
 
-	template <typename T, precision P>
-	struct compute_isCompNull<T, P, tvec4>
+	template<typename T, precision P>
+	struct compute_isCompNull<4, T, P, vec>
 	{
-		GLM_FUNC_QUALIFIER static tvec4<bool, P> call(tvec4<T, P> const & v, T const & epsilon)
+		GLM_FUNC_QUALIFIER static vec<4, bool, P> call(vec<4, T, P> const & v, T const & epsilon)
 		{
-			return tvec4<bool, P>(
+			return vec<4, bool, P>(
 				(abs(v.x) < epsilon),
 				(abs(v.y) < epsilon),
 				(abs(v.z) < epsilon),
@@ -77,24 +77,24 @@ namespace detail
 
 }//namespace detail
 
-	template <typename T, precision P, template <typename, precision> class vecType>
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
 	GLM_FUNC_QUALIFIER bool areCollinear
 	(
-		vecType<T, P> const & v0,
-		vecType<T, P> const & v1,
+		vecType<L, T, P> const& v0,
+		vecType<L, T, P> const& v1,
 		T const & epsilon
 	)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'areCollinear' only accept floating-point inputs");
 
-		return detail::compute_areCollinear<T, P, vecType>::call(v0, v1, epsilon);
+		return detail::compute_areCollinear<L, T, P, vecType>::call(v0, v1, epsilon);
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
 	GLM_FUNC_QUALIFIER bool areOrthogonal
 	(
-		vecType<T, P> const & v0,
-		vecType<T, P> const & v1,
+		vecType<L, T, P> const& v0,
+		vecType<L, T, P> const& v1,
 		T const & epsilon
 	)
 	{
@@ -105,10 +105,10 @@ namespace detail
 			length(v0)) * max(static_cast<T>(1), length(v1)) * epsilon;
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
 	GLM_FUNC_QUALIFIER bool isNormalized
 	(
-		vecType<T, P> const & v,
+		vecType<L, T, P> const& v,
 		T const & epsilon
 	)
 	{
@@ -117,10 +117,10 @@ namespace detail
 		return abs(length(v) - static_cast<T>(1)) <= static_cast<T>(2) * epsilon;
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
 	GLM_FUNC_QUALIFIER bool isNull
 	(
-		vecType<T, P> const & v,
+		vecType<L, T, P> const& v,
 		T const & epsilon
 	)
 	{
@@ -129,61 +129,61 @@ namespace detail
 		return length(v) <= epsilon;
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<bool, P> isCompNull
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, bool, P> isCompNull
 	(
-		vecType<T, P> const & v,
+		vecType<L, T, P> const& v,
 		T const & epsilon
 	)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'isCompNull' only accept floating-point inputs");
 
-		return detail::compute_isCompNull<T, P, vecType>::call(v, epsilon);
+		return detail::compute_isCompNull<L, T, P, vecType>::call(v, epsilon);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<bool, P> isCompNull
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<2, bool, P> isCompNull
 	(
-		tvec2<T, P> const & v,
+		vec<2, T, P> const & v,
 		T const & epsilon)
 	{
-		return tvec2<bool, P>(
+		return vec<2, bool, P>(
 			abs(v.x) < epsilon,
 			abs(v.y) < epsilon);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<bool, P> isCompNull
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<3, bool, P> isCompNull
 	(
-		tvec3<T, P> const & v,
+		vec<3, T, P> const & v,
 		T const & epsilon
 	)
 	{
-		return tvec3<bool, P>(
+		return vec<3, bool, P>(
 			abs(v.x) < epsilon,
 			abs(v.y) < epsilon,
 			abs(v.z) < epsilon);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<bool, P> isCompNull
+	template<typename T, precision P>
+	GLM_FUNC_QUALIFIER vec<4, bool, P> isCompNull
 	(
-		tvec4<T, P> const & v,
+		vec<4, T, P> const & v,
 		T const & epsilon
 	)
 	{
-		return tvec4<bool, P>(
+		return vec<4, bool, P>(
 			abs(v.x) < epsilon,
 			abs(v.y) < epsilon,
 			abs(v.z) < epsilon,
 			abs(v.w) < epsilon);
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
 	GLM_FUNC_QUALIFIER bool areOrthonormal
 	(
-		vecType<T, P> const & v0,
-		vecType<T, P> const & v1,
+		vecType<L, T, P> const& v0,
+		vecType<L, T, P> const& v1,
 		T const & epsilon
 	)
 	{
diff --git a/glm/gtx/wrap.hpp b/glm/gtx/wrap.hpp
index 5db84899..67231c45 100644
--- a/glm/gtx/wrap.hpp
+++ b/glm/gtx/wrap.hpp
@@ -31,22 +31,22 @@ namespace glm
 
 	/// Simulate GL_CLAMP OpenGL wrap mode
 	/// @see gtx_wrap extension.
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL genType clamp(genType const& Texcoord);
 
 	/// Simulate GL_REPEAT OpenGL wrap mode
 	/// @see gtx_wrap extension.
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL genType repeat(genType const& Texcoord);
 
 	/// Simulate GL_MIRRORED_REPEAT OpenGL wrap mode
 	/// @see gtx_wrap extension.
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL genType mirrorClamp(genType const& Texcoord);
 
 	/// Simulate GL_MIRROR_REPEAT OpenGL wrap mode
 	/// @see gtx_wrap extension.
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_DECL genType mirrorRepeat(genType const& Texcoord);
 
 	/// @}
diff --git a/glm/gtx/wrap.inl b/glm/gtx/wrap.inl
index 941a803e..db10dabc 100644
--- a/glm/gtx/wrap.inl
+++ b/glm/gtx/wrap.inl
@@ -3,56 +3,56 @@
 
 namespace glm
 {
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> clamp(vecType<T, P> const& Texcoord)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> clamp(vecType<L, T, P> const& Texcoord)
 	{
-		return glm::clamp(Texcoord, vecType<T, P>(0), vecType<T, P>(1));
+		return glm::clamp(Texcoord, vecType<L, T, P>(0), vecType<L, T, P>(1));
 	}
 
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER genType clamp(genType const & Texcoord)
 	{
-		return clamp(tvec1<genType, defaultp>(Texcoord)).x;
+		return clamp(vec<1, genType, defaultp>(Texcoord)).x;
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> repeat(vecType<T, P> const& Texcoord)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> repeat(vecType<L, T, P> const& Texcoord)
 	{
 		return glm::fract(Texcoord);
 	}
 
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER genType repeat(genType const & Texcoord)
 	{
-		return repeat(tvec1<genType, defaultp>(Texcoord)).x;
+		return repeat(vec<1, genType, defaultp>(Texcoord)).x;
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> mirrorClamp(vecType<T, P> const& Texcoord)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> mirrorClamp(vecType<L, T, P> const& Texcoord)
 	{
 		return glm::fract(glm::abs(Texcoord));
 	}
 
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER genType mirrorClamp(genType const & Texcoord)
 	{
-		return mirrorClamp(tvec1<genType, defaultp>(Texcoord)).x;
+		return mirrorClamp(vec<1, genType, defaultp>(Texcoord)).x;
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> mirrorRepeat(vecType<T, P> const& Texcoord)
+	template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> mirrorRepeat(vecType<L, T, P> const& Texcoord)
 	{
-		vecType<T, P> const Abs = glm::abs(Texcoord);
-		vecType<T, P> const Clamp = glm::mod(glm::floor(Abs), vecType<T, P>(2));
-		vecType<T, P> const Floor = glm::floor(Abs);
-		vecType<T, P> const Rest = Abs - Floor;
-		vecType<T, P> const Mirror = Clamp + Rest;
-		return mix(Rest, vecType<T, P>(1) - Rest, glm::greaterThanEqual(Mirror, vecType<T, P>(1)));
+		vecType<L, T, P> const Abs = glm::abs(Texcoord);
+		vecType<L, T, P> const Clamp = glm::mod(glm::floor(Abs), vecType<L, T, P>(2));
+		vecType<L, T, P> const Floor = glm::floor(Abs);
+		vecType<L, T, P> const Rest = Abs - Floor;
+		vecType<L, T, P> const Mirror = Clamp + Rest;
+		return mix(Rest, vecType<L, T, P>(1) - Rest, glm::greaterThanEqual(Mirror, vecType<L, T, P>(1)));
 	}
 
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER genType mirrorRepeat(genType const& Texcoord)
 	{
-		return mirrorRepeat(tvec1<genType, defaultp>(Texcoord)).x;
+		return mirrorRepeat(vec<1, genType, defaultp>(Texcoord)).x;
 	}
 }//namespace glm
diff --git a/glm/mat2x2.hpp b/glm/mat2x2.hpp
index 420fe9d6..72ebce15 100644
--- a/glm/mat2x2.hpp
+++ b/glm/mat2x2.hpp
@@ -12,41 +12,41 @@ namespace glm
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat2x2<float, lowp>		lowp_mat2;
+	typedef mat<2, 2, float, lowp>		lowp_mat2;
 	
 	/// 2 columns of 2 components matrix of medium precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat2x2<float, mediump>		mediump_mat2;
+	typedef mat<2, 2, float, mediump>		mediump_mat2;
 	
 	/// 2 columns of 2 components matrix of high precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat2x2<float, highp>		highp_mat2;
+	typedef mat<2, 2, float, highp>		highp_mat2;
 	
 	/// 2 columns of 2 components matrix of low precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat2x2<float, lowp>		lowp_mat2x2;
+	typedef mat<2, 2, float, lowp>		lowp_mat2x2;
 	
 	/// 2 columns of 2 components matrix of medium precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat2x2<float, mediump>		mediump_mat2x2;
+	typedef mat<2, 2, float, mediump>		mediump_mat2x2;
 	
 	/// 2 columns of 2 components matrix of high precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat2x2<float, highp>		highp_mat2x2;
+	typedef mat<2, 2, float, highp>		highp_mat2x2;
 
 }//namespace glm
diff --git a/glm/mat2x3.hpp b/glm/mat2x3.hpp
index 5c1cc70b..9e2ba654 100644
--- a/glm/mat2x3.hpp
+++ b/glm/mat2x3.hpp
@@ -12,21 +12,21 @@ namespace glm
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat2x3<float, lowp>		lowp_mat2x3;
+	typedef mat<2, 3, float, lowp>		lowp_mat2x3;
 
 	/// 2 columns of 3 components matrix of medium precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat2x3<float, mediump>		mediump_mat2x3;
+	typedef mat<2, 3, float, mediump>		mediump_mat2x3;
 
 	/// 2 columns of 3 components matrix of high precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat2x3<float, highp>		highp_mat2x3;
+	typedef mat<2, 3, float, highp>		highp_mat2x3;
 
 }//namespace glm
 
diff --git a/glm/mat2x4.hpp b/glm/mat2x4.hpp
index a82f136f..f7905c89 100644
--- a/glm/mat2x4.hpp
+++ b/glm/mat2x4.hpp
@@ -12,20 +12,20 @@ namespace glm
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat2x4<float, lowp>		lowp_mat2x4;
+	typedef mat<2, 4, float, lowp>		lowp_mat2x4;
 	
 	/// 2 columns of 4 components matrix of medium precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat2x4<float, mediump>		mediump_mat2x4;
+	typedef mat<2, 4, float, mediump>		mediump_mat2x4;
 	
 	/// 2 columns of 4 components matrix of high precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat2x4<float, highp>		highp_mat2x4;
+	typedef mat<2, 4, float, highp>		highp_mat2x4;
 
 }//namespace glm
diff --git a/glm/mat3x2.hpp b/glm/mat3x2.hpp
index 40a56dee..d3fce6aa 100644
--- a/glm/mat3x2.hpp
+++ b/glm/mat3x2.hpp
@@ -12,20 +12,20 @@ namespace glm
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat3x2<float, lowp>		lowp_mat3x2;
+	typedef mat<3, 2, float, lowp>		lowp_mat3x2;
 	
 	/// 3 columns of 2 components matrix of medium precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat3x2<float, mediump>		mediump_mat3x2;
+	typedef mat<3, 2, float, mediump>		mediump_mat3x2;
 	
 	/// 3 columns of 2 components matrix of high precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat3x2<float, highp>		highp_mat3x2;
+	typedef mat<3, 2, float, highp>		highp_mat3x2;
 
 }//namespace
diff --git a/glm/mat3x3.hpp b/glm/mat3x3.hpp
index 66bfdfaf..c1963090 100644
--- a/glm/mat3x3.hpp
+++ b/glm/mat3x3.hpp
@@ -12,41 +12,41 @@ namespace glm
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat3x3<float, lowp>		lowp_mat3;
+	typedef mat<3, 3, float, lowp>		lowp_mat3;
 	
 	/// 3 columns of 3 components matrix of medium precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat3x3<float, mediump>		mediump_mat3;
+	typedef mat<3, 3, float, mediump>		mediump_mat3;
 	
 	/// 3 columns of 3 components matrix of high precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat3x3<float, highp>		highp_mat3;
+	typedef mat<3, 3, float, highp>		highp_mat3;
 	
 	/// 3 columns of 3 components matrix of low precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat3x3<float, lowp>		lowp_mat3x3;
+	typedef mat<3, 3, float, lowp>		lowp_mat3x3;
 	
 	/// 3 columns of 3 components matrix of medium precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat3x3<float, mediump>		mediump_mat3x3;
+	typedef mat<3, 3, float, mediump>		mediump_mat3x3;
 	
 	/// 3 columns of 3 components matrix of high precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat3x3<float, highp>		highp_mat3x3;
+	typedef mat<3, 3, float, highp>		highp_mat3x3;
 
 }//namespace glm
diff --git a/glm/mat3x4.hpp b/glm/mat3x4.hpp
index 5f83407a..b2d585dc 100644
--- a/glm/mat3x4.hpp
+++ b/glm/mat3x4.hpp
@@ -12,20 +12,20 @@ namespace glm
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat3x4<float, lowp>		lowp_mat3x4;
+	typedef mat<3, 4, float, lowp>		lowp_mat3x4;
 	
 	/// 3 columns of 4 components matrix of medium precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat3x4<float, mediump>		mediump_mat3x4;
+	typedef mat<3, 4, float, mediump>		mediump_mat3x4;
 	
 	/// 3 columns of 4 components matrix of high precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat3x4<float, highp>		highp_mat3x4;
+	typedef mat<3, 4, float, highp>		highp_mat3x4;
 
 }//namespace glm
diff --git a/glm/mat4x2.hpp b/glm/mat4x2.hpp
index fe67c4fd..654c97c1 100644
--- a/glm/mat4x2.hpp
+++ b/glm/mat4x2.hpp
@@ -12,20 +12,20 @@ namespace glm
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat4x2<float, lowp>		lowp_mat4x2;
+	typedef mat<4, 2, float, lowp>		lowp_mat4x2;
 	
 	/// 4 columns of 2 components matrix of medium precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat4x2<float, mediump>		mediump_mat4x2;
+	typedef mat<4, 2, float, mediump>		mediump_mat4x2;
 	
 	/// 4 columns of 2 components matrix of high precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat4x2<float, highp>		highp_mat4x2;
+	typedef mat<4, 2, float, highp>		highp_mat4x2;
 
 }//namespace glm
diff --git a/glm/mat4x3.hpp b/glm/mat4x3.hpp
index ea1cf883..6b7364a1 100644
--- a/glm/mat4x3.hpp
+++ b/glm/mat4x3.hpp
@@ -12,20 +12,20 @@ namespace glm
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat4x3<float, lowp>		lowp_mat4x3;
+	typedef mat<4, 3, float, lowp>		lowp_mat4x3;
 	
 	/// 4 columns of 3 components matrix of medium precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat4x3<float, mediump>		mediump_mat4x3;
+	typedef mat<4, 3, float, mediump>		mediump_mat4x3;
 	
 	/// 4 columns of 3 components matrix of high precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat4x3<float, highp>		highp_mat4x3;
+	typedef mat<4, 3, float, highp>		highp_mat4x3;
 
 }//namespace glm
diff --git a/glm/mat4x4.hpp b/glm/mat4x4.hpp
index d6c44e8e..30d45dc5 100644
--- a/glm/mat4x4.hpp
+++ b/glm/mat4x4.hpp
@@ -12,41 +12,41 @@ namespace glm
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat4x4<float, lowp>		lowp_mat4;
+	typedef mat<4, 4, float, lowp>		lowp_mat4;
 	
 	/// 4 columns of 4 components matrix of medium precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat4x4<float, mediump>		mediump_mat4;
+	typedef mat<4, 4, float, mediump>		mediump_mat4;
 	
 	/// 4 columns of 4 components matrix of high precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat4x4<float, highp>		highp_mat4;
+	typedef mat<4, 4, float, highp>		highp_mat4;
 	
 	/// 4 columns of 4 components matrix of low precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat4x4<float, lowp>		lowp_mat4x4;
+	typedef mat<4, 4, float, lowp>		lowp_mat4x4;
 	
 	/// 4 columns of 4 components matrix of medium precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat4x4<float, mediump>		mediump_mat4x4;
+	typedef mat<4, 4, float, mediump>		mediump_mat4x4;
 	
 	/// 4 columns of 4 components matrix of high precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef tmat4x4<float, highp>		highp_mat4x4;
+	typedef mat<4, 4, float, highp>		highp_mat4x4;
 
 }//namespace glm
diff --git a/glm/simd/matrix.h b/glm/simd/matrix.h
index 549d40cc..df5a5be2 100644
--- a/glm/simd/matrix.h
+++ b/glm/simd/matrix.h
@@ -410,7 +410,7 @@ GLM_FUNC_QUALIFIER glm_vec4 glm_mat4_determinant_lowp(glm_vec4 const m[4])
 	__m128 MulC = _mm_mul_ps(Swp2C, Swp3C);
 	__m128 SubF = _mm_sub_ps(_mm_movehl_ps(MulC, MulC), MulC);
 
-	//tvec4<T, P> DetCof(
+	//vec<4, T, P> DetCof(
 	//	+ (m[1][1] * SubFactor00 - m[1][2] * SubFactor01 + m[1][3] * SubFactor02),
 	//	- (m[1][0] * SubFactor00 - m[1][2] * SubFactor03 + m[1][3] * SubFactor04),
 	//	+ (m[1][0] * SubFactor01 - m[1][1] * SubFactor03 + m[1][3] * SubFactor05),
@@ -473,7 +473,7 @@ GLM_FUNC_QUALIFIER glm_vec4 glm_mat4_determinant(glm_vec4 const m[4])
 	__m128 MulC = _mm_mul_ps(Swp2C, Swp3C);
 	__m128 SubF = _mm_sub_ps(_mm_movehl_ps(MulC, MulC), MulC);
 
-	//tvec4<T, P> DetCof(
+	//vec<4, T, P> DetCof(
 	//	+ (m[1][1] * SubFactor00 - m[1][2] * SubFactor01 + m[1][3] * SubFactor02),
 	//	- (m[1][0] * SubFactor00 - m[1][2] * SubFactor03 + m[1][3] * SubFactor04),
 	//	+ (m[1][0] * SubFactor01 - m[1][1] * SubFactor03 + m[1][3] * SubFactor05),
@@ -962,7 +962,7 @@ GLM_FUNC_QUALIFIER void glm_mat4_rotate(__m128 const in[4], float Angle, float c
 	__m128 Sin0 = _mm_set_ss(s);
 	__m128 SinA = _mm_shuffle_ps(Sin0, Sin0, _MM_SHUFFLE(0, 0, 0, 0));
 
-	// tvec3<T, P> temp = (valType(1) - c) * axis;
+	// vec<3, T, P> temp = (valType(1) - c) * axis;
 	__m128 Temp0 = _mm_sub_ps(one, CosA);
 	__m128 Temp1 = _mm_mul_ps(Temp0, AxisC);
 	
@@ -1008,7 +1008,7 @@ GLM_FUNC_QUALIFIER void glm_mat4_rotate(__m128 const in[4], float Angle, float c
 	Result[2] = TmpC4;
 	Result[3] = _mm_set_ps(1, 0, 0, 0);
 
-	//tmat4x4<valType> Result(uninitialize);
+	//mat<4, 4, valType> Result(uninitialize);
 	//Result[0] = m[0] * Rotate[0][0] + m[1] * Rotate[0][1] + m[2] * Rotate[0][2];
 	//Result[1] = m[0] * Rotate[1][0] + m[1] * Rotate[1][1] + m[2] * Rotate[1][2];
 	//Result[2] = m[0] * Rotate[2][0] + m[1] * Rotate[2][1] + m[2] * Rotate[2][2];
diff --git a/manual.md b/manual.md
index 1c749d93..792efb19 100644
--- a/manual.md
+++ b/manual.md
@@ -555,7 +555,7 @@ By default GLM only supports basic types as genType for vector, matrix and quate
 ```cpp
 #include <glm/glm.hpp>
 
-typedef glm::tvec4<float> my_fvec4;
+typedef glm::vec<4, float> my_fvec4;
 ```
 
 GLM 0.9.8 introduced GLM\_FORCE\_UNRESTRICTED\_GENTYPE define to relax this restriction:
@@ -566,7 +566,7 @@ GLM 0.9.8 introduced GLM\_FORCE\_UNRESTRICTED\_GENTYPE define to relax this rest
 
 #include "half.hpp" // Define “half� class with equivalent behavior than “float�
 
-typedef glm::tvec4<half> my_hvec4;
+typedef glm::vec<4, half> my_hvec4;
 ```
 
 However, defining GLM\_FORCE\_UNRESTRICTED\_GENTYPE is not compatible with GLM\_FORCE\_SWIZZLE and will generate a compilation error if both are defined at the same time.
diff --git a/test/core/core_func_common.cpp b/test/core/core_func_common.cpp
index 6ff3c393..c33f0d89 100644
--- a/test/core/core_func_common.cpp
+++ b/test/core/core_func_common.cpp
@@ -344,7 +344,7 @@ namespace clamp_
 
 namespace mix_
 {
-	template <typename T, typename B>
+	template<typename T, typename B>
 	struct entry
 	{
 		T x;
@@ -514,7 +514,7 @@ namespace mix_
 
 namespace step_
 {
-	template <typename EDGE, typename VEC>
+	template<typename EDGE, typename VEC>
 	struct entry
 	{
 		EDGE edge;
@@ -817,7 +817,7 @@ namespace isinf_
 
 namespace sign
 {
-	template <typename genFIType> 
+	template<typename genFIType> 
 	GLM_FUNC_QUALIFIER genFIType sign_if(genFIType x)
 	{
 		GLM_STATIC_ASSERT(
@@ -834,7 +834,7 @@ namespace sign
 		return result;
 	}
 
-	template <typename genFIType> 
+	template<typename genFIType> 
 	GLM_FUNC_QUALIFIER genFIType sign_alu1(genFIType x)
 	{
 		GLM_STATIC_ASSERT(
@@ -844,7 +844,7 @@ namespace sign
 		return (x >> 31) | ((unsigned)-x >> 31);
 	}
 
-	template <typename genFIType> 
+	template<typename genFIType> 
 	GLM_FUNC_QUALIFIER genFIType sign_alu2(genFIType x)
 	{
 		GLM_STATIC_ASSERT(
@@ -854,7 +854,7 @@ namespace sign
 		return -((unsigned)x >> 31) | (-(unsigned)x >> 31);
 	}
 
-	template <typename genFIType> 
+	template<typename genFIType> 
 	GLM_FUNC_QUALIFIER genFIType sign_sub(genFIType x)
 	{
 		GLM_STATIC_ASSERT(
@@ -864,7 +864,7 @@ namespace sign
 		return ((unsigned)-x >> 31) - ((unsigned)x >> 31);
 	}
 
-	template <typename genFIType> 
+	template<typename genFIType> 
 	GLM_FUNC_QUALIFIER genFIType sign_cmp(genFIType x)
 	{
 		GLM_STATIC_ASSERT(
@@ -874,7 +874,7 @@ namespace sign
 		return (x > 0) - (x < 0);
 	}
 
-	template <typename genType>
+	template<typename genType>
 	struct type
 	{
 		genType		Value;
diff --git a/test/core/core_func_integer.cpp b/test/core/core_func_integer.cpp
index c44153d8..1a12ff07 100644
--- a/test/core/core_func_integer.cpp
+++ b/test/core/core_func_integer.cpp
@@ -15,7 +15,7 @@ enum result
 
 namespace bitfieldInsert
 {
-	template <typename genType, typename sizeType>
+	template<typename genType, typename sizeType>
 	struct type
 	{
 		genType		Base;
@@ -59,7 +59,7 @@ namespace bitfieldInsert
 
 namespace bitfieldExtract
 {
-	template <typename genType, typename sizeType>
+	template<typename genType, typename sizeType>
 	struct type
 	{
 		genType		Value;
@@ -151,26 +151,26 @@ namespace bitfieldReverse
 		return Result;
 	}
 */
-	template <typename T, glm::precision P, template <typename, glm::precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> bitfieldReverseLoop(vecType<T, P> const & v)
+	template<glm::length_t L, typename T, glm::precision P, template<glm::length_t, typename, glm::precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> bitfieldReverseLoop(vecType<L, T, P> const & v)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_integer, "'bitfieldReverse' only accept integer values");
 
-		vecType<T, P> Result(0);
+		vecType<L, T, P> Result(0);
 		T const BitSize = static_cast<T>(sizeof(T) * 8);
 		for(T i = 0; i < BitSize; ++i)
 		{
-			vecType<T, P> const BitSet(v & (static_cast<T>(1) << i));
-			vecType<T, P> const BitFirst(BitSet >> i);
+			vecType<L, T, P> const BitSet(v & (static_cast<T>(1) << i));
+			vecType<L, T, P> const BitFirst(BitSet >> i);
 			Result |= BitFirst << (BitSize - 1 - i);
 		}
 		return Result;
 	}
 
-	template <typename T>
+	template<typename T>
 	GLM_FUNC_QUALIFIER T bitfieldReverseLoop(T v)
 	{
-		return bitfieldReverseLoop(glm::tvec1<T>(v)).x;
+		return bitfieldReverseLoop(glm::vec<1, T>(v)).x;
 	}
 
 	GLM_FUNC_QUALIFIER glm::uint32_t bitfieldReverseUint32(glm::uint32_t x)
@@ -194,30 +194,30 @@ namespace bitfieldReverse
 		return x;
 	}
 
-	template <bool EXEC = false>
+	template<bool EXEC = false>
 	struct compute_bitfieldReverseStep
 	{
-		template <typename T, glm::precision P, template <class, glm::precision> class vecType>
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & v, T, T)
+		template<glm::length_t L, typename T, glm::precision P, template<glm::length_t, typename, glm::precision> class vecType>
+		GLM_FUNC_QUALIFIER static vecType<L, T, P> call(vecType<L, T, P> const & v, T, T)
 		{
 			return v;
 		}
 	};
 
-	template <>
+	template<>
 	struct compute_bitfieldReverseStep<true>
 	{
-		template <typename T, glm::precision P, template <class, glm::precision> class vecType>
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & v, T Mask, T Shift)
+		template<glm::length_t L, typename T, glm::precision P, template<glm::length_t, typename, glm::precision> class vecType>
+		GLM_FUNC_QUALIFIER static vecType<L, T, P> call(vecType<L, T, P> const & v, T Mask, T Shift)
 		{
 			return (v & Mask) << Shift | (v & (~Mask)) >> Shift;
 		}
 	};
 
-	template <typename T, glm::precision P, template <typename, glm::precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> bitfieldReverseOps(vecType<T, P> const & v)
+	template<glm::length_t L, typename T, glm::precision P, template<glm::length_t, typename, glm::precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> bitfieldReverseOps(vecType<L, T, P> const & v)
 	{
-		vecType<T, P> x(v);
+		vecType<L, T, P> x(v);
 		x = compute_bitfieldReverseStep<sizeof(T) * 8 >=  2>::call(x, T(0x5555555555555555ull), static_cast<T>( 1));
 		x = compute_bitfieldReverseStep<sizeof(T) * 8 >=  4>::call(x, T(0x3333333333333333ull), static_cast<T>( 2));
 		x = compute_bitfieldReverseStep<sizeof(T) * 8 >=  8>::call(x, T(0x0F0F0F0F0F0F0F0Full), static_cast<T>( 4));
@@ -227,13 +227,13 @@ namespace bitfieldReverse
 		return x;
 	}
 
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER genType bitfieldReverseOps(genType x)
 	{
-		return bitfieldReverseOps(glm::tvec1<genType, glm::defaultp>(x)).x;
+		return bitfieldReverseOps(glm::vec<1, genType, glm::defaultp>(x)).x;
 	}
 
-	template <typename genType>
+	template<typename genType>
 	struct type
 	{
 		genType		Value;
@@ -538,7 +538,7 @@ namespace bitfieldReverse
 
 namespace findMSB
 {
-	template <typename genType, typename retType>
+	template<typename genType, typename retType>
 	struct type
 	{
 		genType		Value;
@@ -546,7 +546,7 @@ namespace findMSB
 	};
 
 #	if GLM_HAS_BITSCAN_WINDOWS
-		template <typename genIUType>
+		template<typename genIUType>
 		GLM_FUNC_QUALIFIER int findMSB_intrinsic(genIUType Value)
 		{
 			GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'findMSB' only accept integer values");
@@ -561,7 +561,7 @@ namespace findMSB
 #	endif//GLM_HAS_BITSCAN_WINDOWS
 
 #	if GLM_ARCH & GLM_ARCH_AVX && GLM_COMPILER & GLM_COMPILER_VC
-		template <typename genIUType>
+		template<typename genIUType>
 		GLM_FUNC_QUALIFIER int findMSB_avx(genIUType Value)
 		{
 			GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'findMSB' only accept integer values");
@@ -573,7 +573,7 @@ namespace findMSB
 		}
 #	endif//GLM_ARCH & GLM_ARCH_AVX && GLM_PLATFORM & GLM_PLATFORM_WINDOWS
 
-	template <typename genIUType>
+	template<typename genIUType>
 	GLM_FUNC_QUALIFIER int findMSB_095(genIUType Value)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'findMSB' only accept integer values");
@@ -597,7 +597,7 @@ namespace findMSB
 		}
 	}
 
-	template <typename genIUType>
+	template<typename genIUType>
 	GLM_FUNC_QUALIFIER int findMSB_nlz1(genIUType x)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'findMSB' only accept integer values");
@@ -927,7 +927,7 @@ namespace findMSB
 
 namespace findLSB
 {
-	template <typename genType, typename retType>
+	template<typename genType, typename retType>
 	struct type
 	{
 		genType		Value;
@@ -950,7 +950,7 @@ namespace findLSB
 	};
 
 #	if GLM_HAS_BITSCAN_WINDOWS
-		template <typename genIUType>
+		template<typename genIUType>
 		GLM_FUNC_QUALIFIER int findLSB_intrinsic(genIUType Value)
 		{
 			GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'findLSB' only accept integer values");
@@ -964,7 +964,7 @@ namespace findLSB
 		}
 #	endif
 
-	template <typename genIUType>
+	template<typename genIUType>
 	GLM_FUNC_QUALIFIER int findLSB_095(genIUType Value)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'findLSB' only accept integer values");
@@ -976,7 +976,7 @@ namespace findLSB
 		return Bit;
 	}
 
-	template <typename genIUType>
+	template<typename genIUType>
 	GLM_FUNC_QUALIFIER int findLSB_ntz2(genIUType x)
 	{
 		if(x == 0)
@@ -985,7 +985,7 @@ namespace findLSB
 		return glm::bitCount(~x & (x - static_cast<genIUType>(1)));
 	}
 
-	template <typename genIUType>
+	template<typename genIUType>
 	GLM_FUNC_QUALIFIER int findLSB_branchfree(genIUType x)
 	{
 		bool IsNull(x == 0);
@@ -1361,7 +1361,7 @@ namespace imulExtended
 
 namespace bitCount
 {
-	template <typename genType>
+	template<typename genType>
 	struct type
 	{
 		genType		Value;
@@ -1377,7 +1377,7 @@ namespace bitCount
 		{0x00000000,  0}
 	};
 
-	template <typename T>
+	template<typename T>
 	inline int bitCount_if(T v)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_integer, "'bitCount' only accept integer values");
@@ -1391,7 +1391,7 @@ namespace bitCount
 		return Count;
 	}
 
-	template <typename T>
+	template<typename T>
 	inline int bitCount_vec(T v)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_integer, "'bitCount' only accept integer values");
@@ -1404,43 +1404,43 @@ namespace bitCount
 		return Count;
 	}
 
-	template <bool EXEC = false>
+	template<bool EXEC = false>
 	struct compute_bitfieldBitCountStep
 	{
-		template <typename T, glm::precision P, template <class, glm::precision> class vecType>
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & v, T, T)
+		template<glm::length_t L, typename T, glm::precision P, template<glm::length_t, typename, glm::precision> class vecType>
+		GLM_FUNC_QUALIFIER static vecType<L, T, P> call(vecType<L, T, P> const & v, T, T)
 		{
 			return v;
 		}
 	};
 
-	template <>
+	template<>
 	struct compute_bitfieldBitCountStep<true>
 	{
-		template <typename T, glm::precision P, template <class, glm::precision> class vecType>
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & v, T Mask, T Shift)
+		template<glm::length_t L, typename T, glm::precision P, template<glm::length_t, typename, glm::precision> class vecType>
+		GLM_FUNC_QUALIFIER static vecType<L, T, P> call(vecType<L, T, P> const & v, T Mask, T Shift)
 		{
 			return (v & Mask) + ((v >> Shift) & Mask);
 		}
 	};
 
-	template <typename T, glm::precision P, template <typename, glm::precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<int, P> bitCount_bitfield(vecType<T, P> const & v)
+	template<glm::length_t L, typename T, glm::precision P, template<glm::length_t, typename, glm::precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, int, P> bitCount_bitfield(vecType<L, T, P> const & v)
 	{
-		vecType<typename glm::detail::make_unsigned<T>::type, P> x(*reinterpret_cast<vecType<typename glm::detail::make_unsigned<T>::type, P> const *>(&v));
+		vecType<L, typename glm::detail::make_unsigned<T>::type, P> x(*reinterpret_cast<vecType<L, typename glm::detail::make_unsigned<T>::type, P> const *>(&v));
 		x = compute_bitfieldBitCountStep<sizeof(T) * 8 >=  2>::call(x, typename glm::detail::make_unsigned<T>::type(0x5555555555555555ull), typename glm::detail::make_unsigned<T>::type( 1));
 		x = compute_bitfieldBitCountStep<sizeof(T) * 8 >=  4>::call(x, typename glm::detail::make_unsigned<T>::type(0x3333333333333333ull), typename glm::detail::make_unsigned<T>::type( 2));
 		x = compute_bitfieldBitCountStep<sizeof(T) * 8 >=  8>::call(x, typename glm::detail::make_unsigned<T>::type(0x0F0F0F0F0F0F0F0Full), typename glm::detail::make_unsigned<T>::type( 4));
 		x = compute_bitfieldBitCountStep<sizeof(T) * 8 >= 16>::call(x, typename glm::detail::make_unsigned<T>::type(0x00FF00FF00FF00FFull), typename glm::detail::make_unsigned<T>::type( 8));
 		x = compute_bitfieldBitCountStep<sizeof(T) * 8 >= 32>::call(x, typename glm::detail::make_unsigned<T>::type(0x0000FFFF0000FFFFull), typename glm::detail::make_unsigned<T>::type(16));
 		x = compute_bitfieldBitCountStep<sizeof(T) * 8 >= 64>::call(x, typename glm::detail::make_unsigned<T>::type(0x00000000FFFFFFFFull), typename glm::detail::make_unsigned<T>::type(32));
-		return vecType<int, P>(x);
+		return vecType<L, int, P>(x);
 	}
 
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER int bitCount_bitfield(genType x)
 	{
-		return bitCount_bitfield(glm::tvec1<genType, glm::defaultp>(x)).x;
+		return bitCount_bitfield(glm::vec<1, genType, glm::defaultp>(x)).x;
 	}
 
 	int perf(std::size_t Size)
diff --git a/test/core/core_func_matrix.cpp b/test/core/core_func_matrix.cpp
index 8037deb6..e0c1e8a6 100644
--- a/test/core/core_func_matrix.cpp
+++ b/test/core/core_func_matrix.cpp
@@ -208,7 +208,7 @@ int test_inverse_simd()
 	return Error;
 }
 
-template <typename VEC3, typename MAT4>
+template<typename VEC3, typename MAT4>
 int test_inverse_perf(std::size_t Count, std::size_t Instance, char const * Message)
 {
 	std::vector<MAT4> TestInputs;
diff --git a/test/core/core_setup_message.cpp b/test/core/core_setup_message.cpp
index 23f8f3b8..d8e03fd8 100644
--- a/test/core/core_setup_message.cpp
+++ b/test/core/core_setup_message.cpp
@@ -196,19 +196,19 @@ int test_operators()
 	return (S && !R) ? 0 : 1;
 }
 
-template <typename T>
+template<typename T>
 struct vec
 {
 
 };
 
-template <template <typename> class C, typename T>
+template<template<typename> class C, typename T>
 struct Class
 {
 
 };
 
-template <typename T>
+template<typename T>
 struct Class<vec, T>
 {
 
diff --git a/test/core/core_type_mat2x2.cpp b/test/core/core_type_mat2x2.cpp
index 72f5469a..60ae1b1c 100644
--- a/test/core/core_type_mat2x2.cpp
+++ b/test/core/core_type_mat2x2.cpp
@@ -99,7 +99,7 @@ int test_ctr()
 
 namespace cast
 {
-	template <typename genType>
+	template<typename genType>
 	int entry()
 	{
 		int Error = 0;
diff --git a/test/core/core_type_mat2x3.cpp b/test/core/core_type_mat2x3.cpp
index bb6612cf..a20d0e52 100644
--- a/test/core/core_type_mat2x3.cpp
+++ b/test/core/core_type_mat2x3.cpp
@@ -73,7 +73,7 @@ int test_ctr()
 
 namespace cast
 {
-	template <typename genType>
+	template<typename genType>
 	int entry()
 	{
 		int Error = 0;
diff --git a/test/core/core_type_mat2x4.cpp b/test/core/core_type_mat2x4.cpp
index 5793b2cc..17afebf9 100644
--- a/test/core/core_type_mat2x4.cpp
+++ b/test/core/core_type_mat2x4.cpp
@@ -73,7 +73,7 @@ int test_ctr()
 
 namespace cast
 {
-	template <typename genType>
+	template<typename genType>
 	int entry()
 	{
 		int Error = 0;
diff --git a/test/core/core_type_mat3x2.cpp b/test/core/core_type_mat3x2.cpp
index 449f5773..d3b9e95b 100644
--- a/test/core/core_type_mat3x2.cpp
+++ b/test/core/core_type_mat3x2.cpp
@@ -77,7 +77,7 @@ int test_ctr()
 
 namespace cast
 {
-	template <typename genType>
+	template<typename genType>
 	int entry()
 	{
 		int Error = 0;
diff --git a/test/core/core_type_mat3x3.cpp b/test/core/core_type_mat3x3.cpp
index fa54cefe..013d8b9a 100644
--- a/test/core/core_type_mat3x3.cpp
+++ b/test/core/core_type_mat3x3.cpp
@@ -136,7 +136,7 @@ int test_ctr()
 
 namespace cast
 {
-	template <typename genType>
+	template<typename genType>
 	int entry()
 	{
 		int Error = 0;
diff --git a/test/core/core_type_mat3x4.cpp b/test/core/core_type_mat3x4.cpp
index 112e10a5..e3b78d31 100644
--- a/test/core/core_type_mat3x4.cpp
+++ b/test/core/core_type_mat3x4.cpp
@@ -77,7 +77,7 @@ int test_ctr()
 
 namespace cast
 {
-	template <typename genType>
+	template<typename genType>
 	int entry()
 	{
 		int Error = 0;
diff --git a/test/core/core_type_mat4x2.cpp b/test/core/core_type_mat4x2.cpp
index 247b041f..1a956073 100644
--- a/test/core/core_type_mat4x2.cpp
+++ b/test/core/core_type_mat4x2.cpp
@@ -81,7 +81,7 @@ int test_ctr()
 
 namespace cast
 {
-	template <typename genType>
+	template<typename genType>
 	int entry()
 	{
 		int Error = 0;
diff --git a/test/core/core_type_mat4x3.cpp b/test/core/core_type_mat4x3.cpp
index 6700aae3..e2e50db0 100644
--- a/test/core/core_type_mat4x3.cpp
+++ b/test/core/core_type_mat4x3.cpp
@@ -81,7 +81,7 @@ int test_ctr()
 
 namespace cast
 {
-	template <typename genType>
+	template<typename genType>
 	int entry()
 	{
 		int Error = 0;
diff --git a/test/core/core_type_mat4x4.cpp b/test/core/core_type_mat4x4.cpp
index 0adaef71..036d0dff 100644
--- a/test/core/core_type_mat4x4.cpp
+++ b/test/core/core_type_mat4x4.cpp
@@ -13,7 +13,7 @@
 #include <vector>
 
 
-template <typename genType>
+template<typename genType>
 void print(genType const & Mat0)
 {
 	printf("mat4(\n");
@@ -253,7 +253,7 @@ int perf_mul()
 
 namespace cast
 {
-	template <typename genType>
+	template<typename genType>
 	int entry()
 	{
 		int Error = 0;
diff --git a/test/core/core_type_vec4.cpp b/test/core/core_type_vec4.cpp
index 9ada8878..83ba5ef7 100644
--- a/test/core/core_type_vec4.cpp
+++ b/test/core/core_type_vec4.cpp
@@ -8,7 +8,7 @@
 #include <ctime>
 #include <vector>
 
-template <int Value>
+template<int Value>
 struct mask
 {
 	enum{value = Value};
diff --git a/test/external/gli/clear.hpp b/test/external/gli/clear.hpp
index a109cc7f..db5a98f8 100644
--- a/test/external/gli/clear.hpp
+++ b/test/external/gli/clear.hpp
@@ -40,7 +40,6 @@ namespace gli
 	// Clear multiple layers of a texture
 	template <typename texture_type, typename gen_type>
 	void clear_layer(texture_type& Texture, size_t BaseLayer, size_t LayerCount, gen_type const& BlockData);
-
 }//namespace gli
 
 #include "./core/clear.inl"
diff --git a/test/external/gli/convert.hpp b/test/external/gli/convert.hpp
index 36ea2bd7..21d90d9a 100644
--- a/test/external/gli/convert.hpp
+++ b/test/external/gli/convert.hpp
@@ -19,7 +19,6 @@ namespace gli
 	/// @param Format Destination Texture format, it must be uncompressed.
 	template <typename texture_type>
 	texture_type convert(texture_type const& Texture, format Format);
-
 }//namespace gli
 
 #include "./core/convert.inl"
diff --git a/test/external/gli/core/clear.hpp b/test/external/gli/core/clear.hpp
index 20c94221..8516c371 100644
--- a/test/external/gli/core/clear.hpp
+++ b/test/external/gli/core/clear.hpp
@@ -8,7 +8,7 @@ namespace detail
 	template <typename textureType, typename T, precision P>
 	struct clear
 	{
-		static void call(textureType & Texture, typename convert<textureType, T, P>::writeFunc Write, tvec4<T, P> const & Color)
+		static void call(textureType & Texture, typename convert<textureType, T, P>::writeFunc Write, vec<4, T, P> const& Color)
 		{
 			GLI_ASSERT(Write);
 
diff --git a/test/external/gli/core/convert_func.hpp b/test/external/gli/core/convert_func.hpp
index d660e573..b16bea0f 100644
--- a/test/external/gli/core/convert_func.hpp
+++ b/test/external/gli/core/convert_func.hpp
@@ -157,264 +157,264 @@ namespace detail
 
 	// convertFunc class
 
-	template <typename textureType, typename retType, typename T, precision P, template <typename, precision> class vecType, convertMode mode = CONVERT_MODE_CAST, bool isSamplerFloat = false>
+	template <typename textureType, typename retType, length_t L, typename T, precision P, convertMode mode = CONVERT_MODE_CAST, bool isSamplerFloat = false>
 	struct convertFunc
 	{
-		typedef accessFunc<textureType, vecType<T, P> > access;
+		typedef accessFunc<textureType, vec<L, T, P> > access;
 
-		static tvec4<retType, P> fetch(textureType const & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level)
+		static vec<4, retType, P> fetch(textureType const & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level)
 		{
-			return make_vec4<retType, P>(vecType<retType, P>(access::load(Texture, TexelCoord, Layer, Face, Level)));
+			return make_vec4<retType, P>(vec<L, retType, P>(access::load(Texture, TexelCoord, Layer, Face, Level)));
 		}
 
-		static void write(textureType & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level, tvec4<retType, P> const & Texel)
+		static void write(textureType & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level, vec<4, retType, P> const & Texel)
 		{
-			access::store(Texture, TexelCoord, Layer, Face, Level, vecType<T, P>(Texel));
+			access::store(Texture, TexelCoord, Layer, Face, Level, vec<L, T, P>(Texel));
 		}
 	};
 
-	template <typename textureType, typename retType, typename T, precision P, template <typename, precision> class vecType, bool isSamplerFloat>
-	struct convertFunc<textureType, retType, T, P, vecType, CONVERT_MODE_DEFAULT, isSamplerFloat>
+	template <typename textureType, typename retType, length_t L, typename T, precision P, bool isSamplerFloat>
+	struct convertFunc<textureType, retType, L, T, P, CONVERT_MODE_DEFAULT, isSamplerFloat>
 	{
-		static tvec4<retType, P> fetch(textureType const & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level)
+		static vec<4, retType, P> fetch(textureType const & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level)
 		{
-			return tvec4<retType, P>(0, 0, 0, 1);
+			return vec<4, retType, P>(0, 0, 0, 1);
 		}
 
-		static void write(textureType & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level, tvec4<retType, P> const & Texel)
+		static void write(textureType & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level, vec<4, retType, P> const & Texel)
 		{}
 	};
 
-	template <typename textureType, typename retType, typename T, precision P, template <typename, precision> class vecType>
-	struct convertFunc<textureType, retType, T, P, vecType, CONVERT_MODE_NORM, true>
+	template <typename textureType, typename retType, length_t L, typename T, precision P>
+	struct convertFunc<textureType, retType, L, T, P, CONVERT_MODE_NORM, true>
 	{
-		typedef accessFunc<textureType, vecType<T, P> > access;
+		typedef accessFunc<textureType, vec<L, T, P> > access;
 
-		static tvec4<retType, P> fetch(textureType const & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level)
+		static vec<4, retType, P> fetch(textureType const & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level)
 		{
 			static_assert(std::numeric_limits<retType>::is_iec559, "CONVERT_MODE_NORM requires a float sampler");
 			return make_vec4<retType, P>(compNormalize<retType>(access::load(Texture, TexelCoord, Layer, Face, Level)));
 		}
 
-		static void write(textureType & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level, tvec4<retType, P> const & Texel)
+		static void write(textureType & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level, vec<4, retType, P> const & Texel)
 		{
 			static_assert(std::numeric_limits<retType>::is_iec559, "CONVERT_MODE_NORM requires a float sampler");
-			access::store(Texture, TexelCoord, Layer, Face, Level, compScale<T>(vecType<retType, P>(Texel)));
+			access::store(Texture, TexelCoord, Layer, Face, Level, compScale<T>(vec<L, retType, P>(Texel)));
 		}
 	};
 
-	template <typename textureType, typename retType, typename T, precision P, template <typename, precision> class vecType>
-	struct convertFunc<textureType, retType, T, P, vecType, CONVERT_MODE_SRGB, true>
+	template <typename textureType, typename retType, length_t L, typename T, precision P>
+	struct convertFunc<textureType, retType, L, T, P, CONVERT_MODE_SRGB, true>
 	{
-		typedef accessFunc<textureType, vecType<T, P> > access;
+		typedef accessFunc<textureType, vec<L, T, P> > access;
 
-		static tvec4<retType, P> fetch(textureType const & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level)
+		static vec<4, retType, P> fetch(textureType const & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level)
 		{
 			static_assert(std::numeric_limits<retType>::is_iec559, "CONVERT_MODE_SRGB requires a float sampler");
 			return make_vec4<retType, P>(convertSRGBToLinear(compNormalize<retType>(access::load(Texture, TexelCoord, Layer, Face, Level))));
 		}
 
-		static void write(textureType & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level, tvec4<retType, P> const & Texel)
+		static void write(textureType & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level, vec<4, retType, P> const & Texel)
 		{
 			static_assert(std::numeric_limits<retType>::is_iec559, "CONVERT_MODE_SRGB requires a float sampler");
-			access::store(Texture, TexelCoord, Layer, Face, Level, gli::compScale<T>(convertLinearToSRGB(vecType<retType, P>(Texel))));
+			access::store(Texture, TexelCoord, Layer, Face, Level, gli::compScale<T>(convertLinearToSRGB(vec<L, retType, P>(Texel))));
 		}
 	};
 
-	template <typename textureType, typename retType, typename T, precision P, template <typename, precision> class vecType>
-	struct convertFunc<textureType, retType, T, P, vecType, CONVERT_MODE_RGB9E5, true>
+	template <typename textureType, typename retType, length_t L, typename T, precision P>
+	struct convertFunc<textureType, retType, L, T, P, CONVERT_MODE_RGB9E5, true>
 	{
 		typedef accessFunc<textureType, uint32> access;
 
-		static tvec4<retType, P> fetch(textureType const & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level)
+		static vec<4, retType, P> fetch(textureType const & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level)
 		{
 			static_assert(std::numeric_limits<retType>::is_iec559, "CONVERT_MODE_RGB9E5 requires a float sampler");
-			return tvec4<retType, P>(unpackF3x9_E1x5(access::load(Texture, TexelCoord, Layer, Face, Level)), static_cast<retType>(1));
+			return vec<4, retType, P>(unpackF3x9_E1x5(access::load(Texture, TexelCoord, Layer, Face, Level)), static_cast<retType>(1));
 		}
 
-		static void write(textureType & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level, tvec4<retType, P> const & Texel)
+		static void write(textureType & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level, vec<4, retType, P> const & Texel)
 		{
 			static_assert(std::numeric_limits<retType>::is_iec559, "CONVERT_MODE_RGB9E5 requires a float sampler");
-			access::store(Texture, TexelCoord, Layer, Face, Level, packF3x9_E1x5(tvec3<float, P>(Texel)));
+			access::store(Texture, TexelCoord, Layer, Face, Level, packF3x9_E1x5(vec<3, float, P>(Texel)));
 		}
 	};
 
-	template <typename textureType, typename retType, typename T, precision P, template <typename, precision> class vecType>
-	struct convertFunc<textureType, retType, T, P, vecType, CONVERT_MODE_RG11B10F, true>
+	template <typename textureType, typename retType, length_t L, typename T, precision P>
+	struct convertFunc<textureType, retType, L, T, P, CONVERT_MODE_RG11B10F, true>
 	{
 		typedef accessFunc<textureType, uint32> access;
 
-		static tvec4<retType, P> fetch(textureType const & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level)
+		static vec<4, retType, P> fetch(textureType const & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level)
 		{
 			static_assert(std::numeric_limits<retType>::is_iec559, "CONVERT_MODE_RG11B10F requires a float sampler");
-			return tvec4<retType, P>(unpackF2x11_1x10(access::load(Texture, TexelCoord, Layer, Face, Level)), static_cast<retType>(1));
+			return vec<4, retType, P>(unpackF2x11_1x10(access::load(Texture, TexelCoord, Layer, Face, Level)), static_cast<retType>(1));
 		}
 
-		static void write(textureType & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level, tvec4<retType, P> const & Texel)
+		static void write(textureType & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level, vec<4, retType, P> const & Texel)
 		{
 			static_assert(std::numeric_limits<retType>::is_iec559, "CONVERT_MODE_RG11B10F requires a float sampler");
-			access::store(Texture, TexelCoord, Layer, Face, Level, packF2x11_1x10(tvec3<float, P>(Texel)));
+			access::store(Texture, TexelCoord, Layer, Face, Level, packF2x11_1x10(vec<3, float, P>(Texel)));
 		}
 	};
 
-	template <typename textureType, typename retType, typename T, precision P, template <typename, precision> class vecType>
-	struct convertFunc<textureType, retType, T, P, vecType, CONVERT_MODE_HALF, true>
+	template <typename textureType, typename retType, length_t L, typename T, precision P>
+	struct convertFunc<textureType, retType, L, T, P, CONVERT_MODE_HALF, true>
 	{
-		typedef accessFunc<textureType, vecType<uint16, P> > access;
+		typedef accessFunc<textureType, vec<L, uint16, P> > access;
 
-		static tvec4<retType, P> fetch(textureType const & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level)
+		static vec<4, retType, P> fetch(textureType const & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level)
 		{
 			static_assert(std::numeric_limits<retType>::is_iec559, "CONVERT_MODE_HALF requires a float sampler");
-			return make_vec4<retType, P>(vecType<retType, P>(unpackHalf(access::load(Texture, TexelCoord, Layer, Face, Level))));
+			return make_vec4<retType, P>(vec<L, retType, P>(unpackHalf(access::load(Texture, TexelCoord, Layer, Face, Level))));
 		}
 
-		static void write(textureType & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level, tvec4<retType, P> const & Texel)
+		static void write(textureType & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level, vec<4, retType, P> const & Texel)
 		{
 			static_assert(std::numeric_limits<retType>::is_iec559, "CONVERT_MODE_HALF requires a float sampler");
-			access::store(Texture, TexelCoord, Layer, Face, Level, packHalf(vecType<float, P>(Texel)));
+			access::store(Texture, TexelCoord, Layer, Face, Level, packHalf(vec<L, float, P>(Texel)));
 		}
 	};
 
-	template <typename textureType, typename retType, typename T, precision P, template <typename, precision> class vecType>
-	struct convertFunc<textureType, retType, T, P, vecType, CONVERT_MODE_44UNORM, true>
+	template <typename textureType, typename retType, length_t L, typename T, precision P>
+	struct convertFunc<textureType, retType, L, T, P, CONVERT_MODE_44UNORM, true>
 	{
 		typedef accessFunc<textureType, uint8> access;
 
-		static tvec4<retType, P> fetch(textureType const & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level)
+		static vec<4, retType, P> fetch(textureType const & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level)
 		{
 			static_assert(std::numeric_limits<retType>::is_iec559, "CONVERT_MODE_44UNORM requires a float sampler");
-			return tvec4<retType, P>(tvec2<retType, P>(unpackUnorm2x4(access::load(Texture, TexelCoord, Layer, Face, Level))), static_cast<retType>(0), static_cast<retType>(1));
+			return vec<4, retType, P>(vec<2, retType, P>(unpackUnorm2x4(access::load(Texture, TexelCoord, Layer, Face, Level))), static_cast<retType>(0), static_cast<retType>(1));
 		}
 
-		static void write(textureType & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level, tvec4<retType, P> const & Texel)
+		static void write(textureType & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level, vec<4, retType, P> const & Texel)
 		{
 			static_assert(std::numeric_limits<retType>::is_iec559, "CONVERT_MODE_44UNORM requires a float sampler");
-			access::store(Texture, TexelCoord, Layer, Face, Level, packUnorm2x4(tvec2<float, P>(Texel)));
+			access::store(Texture, TexelCoord, Layer, Face, Level, packUnorm2x4(vec<2, float, P>(Texel)));
 		}
 	};
 
-	template <typename textureType, typename retType, typename T, precision P, template <typename, precision> class vecType>
-	struct convertFunc<textureType, retType, T, P, vecType, CONVERT_MODE_4444UNORM, true>
+	template <typename textureType, typename retType, length_t L, typename T, precision P>
+	struct convertFunc<textureType, retType, L, T, P, CONVERT_MODE_4444UNORM, true>
 	{
 		typedef accessFunc<textureType, uint16> access;
 
-		static tvec4<retType, P> fetch(textureType const & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level)
+		static vec<4, retType, P> fetch(textureType const & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level)
 		{
 			static_assert(std::numeric_limits<retType>::is_iec559, "CONVERT_MODE_4444UNORM requires a float sampler");
-			return tvec4<retType, P>(unpackUnorm4x4(access::load(Texture, TexelCoord, Layer, Face, Level)));
+			return vec<4, retType, P>(unpackUnorm4x4(access::load(Texture, TexelCoord, Layer, Face, Level)));
 		}
 
-		static void write(textureType & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level, tvec4<retType, P> const & Texel)
+		static void write(textureType & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level, vec<4, retType, P> const & Texel)
 		{
 			static_assert(std::numeric_limits<retType>::is_iec559, "CONVERT_MODE_4444UNORM requires a float sampler");
-			access::store(Texture, TexelCoord, Layer, Face, Level, packUnorm4x4(tvec4<float, P>(Texel)));
+			access::store(Texture, TexelCoord, Layer, Face, Level, packUnorm4x4(vec<4, float, P>(Texel)));
 		}
 	};
 
-	template <typename textureType, typename retType, typename T, precision P, template <typename, precision> class vecType>
-	struct convertFunc<textureType, retType, T, P, vecType, CONVERT_MODE_565UNORM, true>
+	template <typename textureType, typename retType, length_t L, typename T, precision P>
+	struct convertFunc<textureType, retType, L, T, P, CONVERT_MODE_565UNORM, true>
 	{
 		typedef accessFunc<textureType, uint16> access;
 
-		static tvec4<retType, P> fetch(textureType const & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level)
+		static vec<4, retType, P> fetch(textureType const & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level)
 		{
 			static_assert(std::numeric_limits<retType>::is_iec559, "CONVERT_MODE_565UNORM requires a float sampler");
-			return tvec4<retType, P>(unpackUnorm1x5_1x6_1x5(access::load(Texture, TexelCoord, Layer, Face, Level)), static_cast<retType>(1));
+			return vec<4, retType, P>(unpackUnorm1x5_1x6_1x5(access::load(Texture, TexelCoord, Layer, Face, Level)), static_cast<retType>(1));
 		}
 
-		static void write(textureType & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level, tvec4<retType, P> const & Texel)
+		static void write(textureType & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level, vec<4, retType, P> const & Texel)
 		{
 			static_assert(std::numeric_limits<retType>::is_iec559, "CONVERT_MODE_565UNORM requires a float sampler");
-			access::store(Texture, TexelCoord, Layer, Face, Level, packUnorm1x5_1x6_1x5(tvec3<float, P>(Texel)));
+			access::store(Texture, TexelCoord, Layer, Face, Level, packUnorm1x5_1x6_1x5(vec<3, float, P>(Texel)));
 		}
 	};
 
-	template <typename textureType, typename retType, typename T, precision P, template <typename, precision> class vecType>
-	struct convertFunc<textureType, retType, T, P, vecType, CONVERT_MODE_5551UNORM, true>
+	template <typename textureType, typename retType, length_t L, typename T, precision P>
+	struct convertFunc<textureType, retType, L, T, P, CONVERT_MODE_5551UNORM, true>
 	{
 		typedef accessFunc<textureType, uint16> access;
 
-		static tvec4<retType, P> fetch(textureType const & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level)
+		static vec<4, retType, P> fetch(textureType const & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level)
 		{
 			static_assert(std::numeric_limits<retType>::is_iec559, "CONVERT_MODE_5551UNORM requires a float sampler");
-			return tvec4<retType, P>(unpackUnorm3x5_1x1(access::load(Texture, TexelCoord, Layer, Face, Level)));
+			return vec<4, retType, P>(unpackUnorm3x5_1x1(access::load(Texture, TexelCoord, Layer, Face, Level)));
 		}
 
-		static void write(textureType & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level, tvec4<retType, P> const & Texel)
+		static void write(textureType & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level, vec<4, retType, P> const & Texel)
 		{
 			static_assert(std::numeric_limits<retType>::is_iec559, "CONVERT_MODE_5551UNORM requires a float sampler");
-			access::store(Texture, TexelCoord, Layer, Face, Level, packUnorm3x5_1x1(tvec4<float, P>(Texel)));
+			access::store(Texture, TexelCoord, Layer, Face, Level, packUnorm3x5_1x1(vec<4, float, P>(Texel)));
 		}
 	};
 
-	template <typename textureType, typename retType, typename T, precision P, template <typename, precision> class vecType>
-	struct convertFunc<textureType, retType, T, P, vecType, CONVERT_MODE_332UNORM, true>
+	template <typename textureType, typename retType, length_t L, typename T, precision P>
+	struct convertFunc<textureType, retType, L, T, P, CONVERT_MODE_332UNORM, true>
 	{
 		typedef accessFunc<textureType, uint8> access;
 
-		static tvec4<retType, P> fetch(textureType const & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level)
+		static vec<4, retType, P> fetch(textureType const & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level)
 		{
 			static_assert(std::numeric_limits<retType>::is_iec559, "CONVERT_MODE_332UNORM requires a float sampler");
-			return tvec4<retType, P>(unpackUnorm2x3_1x2(access::load(Texture, TexelCoord, Layer, Face, Level)), static_cast<retType>(1));
+			return vec<4, retType, P>(unpackUnorm2x3_1x2(access::load(Texture, TexelCoord, Layer, Face, Level)), static_cast<retType>(1));
 		}
 
-		static void write(textureType & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level, tvec4<retType, P> const & Texel)
+		static void write(textureType & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level, vec<4, retType, P> const & Texel)
 		{
 			static_assert(std::numeric_limits<retType>::is_iec559, "CONVERT_MODE_332UNORM requires a float sampler");
-			access::store(Texture, TexelCoord, Layer, Face, Level, packUnorm2x3_1x2(tvec3<float, P>(Texel)));
+			access::store(Texture, TexelCoord, Layer, Face, Level, packUnorm2x3_1x2(vec<3, float, P>(Texel)));
 		}
 	};
 
-	template <typename textureType, typename retType, typename T, precision P, template <typename, precision> class vecType>
-	struct convertFunc<textureType, retType, T, P, vecType, CONVERT_MODE_RGB10A2UNORM, true>
+	template <typename textureType, typename retType, length_t L, typename T, precision P>
+	struct convertFunc<textureType, retType, L, T, P, CONVERT_MODE_RGB10A2UNORM, true>
 	{
 		typedef accessFunc<textureType, uint32> access;
 
-		static tvec4<retType, P> fetch(textureType const & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level)
+		static vec<4, retType, P> fetch(textureType const & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level)
 		{
 			static_assert(std::numeric_limits<retType>::is_iec559, "CONVERT_MODE_RGB10A2UNORM requires a float sampler");
-			return tvec4<retType, P>(unpackUnorm3x10_1x2(access::load(Texture, TexelCoord, Layer, Face, Level)));
+			return vec<4, retType, P>(unpackUnorm3x10_1x2(access::load(Texture, TexelCoord, Layer, Face, Level)));
 		}
 
-		static void write(textureType & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level, tvec4<retType, P> const & Texel)
+		static void write(textureType & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level, vec<4, retType, P> const & Texel)
 		{
 			static_assert(std::numeric_limits<retType>::is_iec559, "CONVERT_MODE_RGB10A2UNORM requires a float sampler");
-			access::store(Texture, TexelCoord, Layer, Face, Level, packUnorm3x10_1x2(tvec4<float, P>(Texel)));
+			access::store(Texture, TexelCoord, Layer, Face, Level, packUnorm3x10_1x2(vec<4, float, P>(Texel)));
 		}
 	};
 
-	template <typename textureType, typename retType, typename T, precision P, template <typename, precision> class vecType>
-	struct convertFunc<textureType, retType, T, P, vecType, CONVERT_MODE_RGB10A2SNORM, true>
+	template <typename textureType, typename retType, length_t L, typename T, precision P>
+	struct convertFunc<textureType, retType, L, T, P, CONVERT_MODE_RGB10A2SNORM, true>
 	{
 		typedef accessFunc<textureType, uint32> access;
 
-		static tvec4<retType, P> fetch(textureType const & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level)
+		static vec<4, retType, P> fetch(textureType const & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level)
 		{
 			static_assert(std::numeric_limits<retType>::is_iec559, "CONVERT_MODE_RGB10A2SNORM requires a float sampler");
-			return tvec4<retType, P>(unpackSnorm3x10_1x2(access::load(Texture, TexelCoord, Layer, Face, Level)));
+			return vec<4, retType, P>(unpackSnorm3x10_1x2(access::load(Texture, TexelCoord, Layer, Face, Level)));
 		}
 
-		static void write(textureType & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level, tvec4<retType, P> const & Texel)
+		static void write(textureType & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level, vec<4, retType, P> const & Texel)
 		{
 			static_assert(std::numeric_limits<retType>::is_iec559, "CONVERT_MODE_RGB10A2SNORM requires a float sampler");
 			access::store(Texture, TexelCoord, Layer, Face, Level, packSnorm3x10_1x2(Texel));
 		}
 	};
 
-	template <typename textureType, typename retType, typename T, precision P, template <typename, precision> class vecType>
-	struct convertFunc<textureType, retType, T, P, vecType, CONVERT_MODE_RGB10A2USCALE, true>
+	template <typename textureType, typename retType, length_t L, typename T, precision P>
+	struct convertFunc<textureType, retType, L, T, P, CONVERT_MODE_RGB10A2USCALE, true>
 	{
 		typedef accessFunc<textureType, uint32> access;
 
-		static tvec4<retType, P> fetch(textureType const & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level)
+		static vec<4, retType, P> fetch(textureType const & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level)
 		{
 			static_assert(std::numeric_limits<retType>::is_iec559, "CONVERT_MODE_RGB10A2USCALE requires a float sampler");
 			glm::detail::u10u10u10u2 Unpack;
 			Unpack.pack = access::load(Texture, TexelCoord, Layer, Face, Level);
-			return tvec4<retType, P>(Unpack.data.x, Unpack.data.y, Unpack.data.z, Unpack.data.w);
+			return vec<4, retType, P>(Unpack.data.x, Unpack.data.y, Unpack.data.z, Unpack.data.w);
 		}
 
-		static void write(textureType & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level, tvec4<retType, P> const & Texel)
+		static void write(textureType & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level, vec<4, retType, P> const & Texel)
 		{
 			static_assert(std::numeric_limits<retType>::is_iec559, "CONVERT_MODE_RGB10A2USCALE requires a float sampler");
 			glm::detail::u10u10u10u2 Unpack;
@@ -426,20 +426,20 @@ namespace detail
 		}
 	};
 
-	template <typename textureType, typename retType, typename T, precision P, template <typename, precision> class vecType>
-	struct convertFunc<textureType, retType, T, P, vecType, CONVERT_MODE_RGB10A2SSCALE, true>
+	template <typename textureType, typename retType, length_t L, typename T, precision P>
+	struct convertFunc<textureType, retType, L, T, P, CONVERT_MODE_RGB10A2SSCALE, true>
 	{
 		typedef accessFunc<textureType, uint32> access;
 
-		static tvec4<retType, P> fetch(textureType const & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level)
+		static vec<4, retType, P> fetch(textureType const & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level)
 		{
 			static_assert(std::numeric_limits<retType>::is_iec559, "CONVERT_MODE_RGB10A2SSCALE requires a float sampler");
 			glm::detail::i10i10i10i2 Unpack;
 			Unpack.pack = access::load(Texture, TexelCoord, Layer, Face, Level);
-			return tvec4<retType, P>(Unpack.data.x, Unpack.data.y, Unpack.data.z, Unpack.data.w);
+			return vec<4, retType, P>(Unpack.data.x, Unpack.data.y, Unpack.data.z, Unpack.data.w);
 		}
 
-		static void write(textureType & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level, tvec4<retType, P> const & Texel)
+		static void write(textureType & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level, vec<4, retType, P> const & Texel)
 		{
 			static_assert(std::numeric_limits<retType>::is_iec559, "CONVERT_MODE_RGB10A2SSCALE requires a float sampler");
 			glm::detail::i10i10i10i2 Unpack;
@@ -451,36 +451,36 @@ namespace detail
 		}
 	};
 
-	template <typename textureType, typename retType, typename T, precision P, template <typename, precision> class vecType>
-	struct convertFunc<textureType, retType, T, P, vecType, CONVERT_MODE_RGB10A2UINT, false>
+	template <typename textureType, typename retType, length_t L, typename T, precision P>
+	struct convertFunc<textureType, retType, L, T, P, CONVERT_MODE_RGB10A2UINT, false>
 	{
 		typedef accessFunc<textureType, uint32> access;
 
-		static tvec4<retType, P> fetch(textureType const & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level)
+		static vec<4, retType, P> fetch(textureType const & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level)
 		{
 			static_assert(std::numeric_limits<retType>::is_integer, "CONVERT_MODE_RGB10A2UINT requires an integer sampler");
-			return tvec4<retType, P>(unpackU3x10_1x2(access::load(Texture, TexelCoord, Layer, Face, Level)));
+			return vec<4, retType, P>(unpackU3x10_1x2(access::load(Texture, TexelCoord, Layer, Face, Level)));
 		}
 
-		static void write(textureType & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level, tvec4<retType, P> const & Texel)
+		static void write(textureType & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level, vec<4, retType, P> const & Texel)
 		{
 			static_assert(std::numeric_limits<retType>::is_integer, "CONVERT_MODE_RGB10A2UINT requires an integer sampler");
 			access::store(Texture, TexelCoord, Layer, Face, Level, packU3x10_1x2(Texel));
 		}
 	};
 
-	template <typename textureType, typename retType, typename T, precision P, template <typename, precision> class vecType>
-	struct convertFunc<textureType, retType, T, P, vecType, CONVERT_MODE_RGB10A2SINT, false>
+	template <typename textureType, typename retType, length_t L, typename T, precision P>
+	struct convertFunc<textureType, retType, L, T, P, CONVERT_MODE_RGB10A2SINT, false>
 	{
 		typedef accessFunc<textureType, uint32> access;
 
-		static tvec4<retType, P> fetch(textureType const & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level)
+		static vec<4, retType, P> fetch(textureType const & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level)
 		{
 			static_assert(std::numeric_limits<retType>::is_integer, "CONVERT_MODE_RGB10A2SINT requires an integer sampler");
-			return tvec4<retType, P>(unpackI3x10_1x2(access::load(Texture, TexelCoord, Layer, Face, Level)));
+			return vec<4, retType, P>(unpackI3x10_1x2(access::load(Texture, TexelCoord, Layer, Face, Level)));
 		}
 
-		static void write(textureType & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level, tvec4<retType, P> const & Texel)
+		static void write(textureType & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level, vec<4, retType, P> const & Texel)
 		{
 			static_assert(std::numeric_limits<retType>::is_integer, "CONVERT_MODE_RGB10A2SINT requires an integer sampler");
 			access::store(Texture, TexelCoord, Layer, Face, Level, packI3x10_1x2(Texel));
@@ -490,20 +490,20 @@ namespace detail
 	template <typename textureType, typename samplerValType, precision P>
 	struct convert
 	{
-		typedef glm::tvec4<samplerValType, P>(*fetchFunc)(textureType const & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level);
-		typedef void(*writeFunc)(textureType & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level, glm::tvec4<samplerValType, P> const & Texel);
+		typedef vec<4, samplerValType, P>(*fetchFunc)(textureType const & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level);
+		typedef void(*writeFunc)(textureType & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level, vec<4, samplerValType, P> const & Texel);
 
-		template <typename T, template <typename, precision> class vecType, convertMode mode>
+		template <length_t L, typename T, convertMode mode>
 		struct conv
 		{
-			static tvec4<samplerValType, P> fetch(textureType const & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level)
+			static vec<4, samplerValType, P> fetch(textureType const & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level)
 			{
-				return convertFunc<textureType, samplerValType, T, P, vecType, mode, std::numeric_limits<samplerValType>::is_iec559>::fetch(Texture, TexelCoord, Layer, Face, Level);
+				return convertFunc<textureType, samplerValType, L, T, P, mode, std::numeric_limits<samplerValType>::is_iec559>::fetch(Texture, TexelCoord, Layer, Face, Level);
 			}
 
-			static void write(textureType & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level, tvec4<samplerValType, P> const & Texel)
+			static void write(textureType & Texture, typename textureType::extent_type const & TexelCoord, typename textureType::size_type Layer, typename textureType::size_type Face, typename textureType::size_type Level, vec<4, samplerValType, P> const & Texel)
 			{
-				convertFunc<textureType, samplerValType, T, P, vecType, mode, std::numeric_limits<samplerValType>::is_iec559>::write(Texture, TexelCoord, Layer, Face, Level, Texel);
+				convertFunc<textureType, samplerValType, L, T, P, mode, std::numeric_limits<samplerValType>::is_iec559>::write(Texture, TexelCoord, Layer, Face, Level, Texel);
 			}
 		};
 
@@ -517,246 +517,246 @@ namespace detail
 		{
 			static func Table[] =
 			{
-				{conv<u8, tvec2, CONVERT_MODE_44UNORM>::fetch, conv<u8, tvec2, CONVERT_MODE_44UNORM>::write},				// FORMAT_RG4_UNORM
-				{conv<u8, tvec4, CONVERT_MODE_4444UNORM>::fetch, conv<u8, tvec4, CONVERT_MODE_4444UNORM>::write},			// FORMAT_RGBA4_UNORM
-				{conv<u8, tvec4, CONVERT_MODE_4444UNORM>::fetch, conv<u8, tvec4, CONVERT_MODE_4444UNORM>::write},			// FORMAT_BGRA4_UNORM
-				{conv<u8, tvec3, CONVERT_MODE_565UNORM>::fetch, conv<u8, tvec3, CONVERT_MODE_565UNORM>::write},				// FORMAT_R5G6B5_UNORM
-				{conv<u8, tvec3, CONVERT_MODE_565UNORM>::fetch, conv<u8, tvec3, CONVERT_MODE_565UNORM>::write},				// FORMAT_B5G6R5_UNORM
-				{conv<u8, tvec4, CONVERT_MODE_5551UNORM>::fetch, conv<u8, tvec4, CONVERT_MODE_5551UNORM>::write},			// FORMAT_RGB5A1_UNORM
-				{conv<u8, tvec4, CONVERT_MODE_5551UNORM>::fetch, conv<u8, tvec4, CONVERT_MODE_5551UNORM>::write},			// FORMAT_BGR5A1_UNORM
-				{conv<u8, tvec4, CONVERT_MODE_5551UNORM>::fetch, conv<u8, tvec4, CONVERT_MODE_5551UNORM>::write},			// FORMAT_A1RGB5_UNORM
+				{conv<2, u8, CONVERT_MODE_44UNORM>::fetch, conv<2, u8, CONVERT_MODE_44UNORM>::write},				// FORMAT_RG4_UNORM
+				{conv<4, u8, CONVERT_MODE_4444UNORM>::fetch, conv<4, u8, CONVERT_MODE_4444UNORM>::write},			// FORMAT_RGBA4_UNORM
+				{conv<4, u8, CONVERT_MODE_4444UNORM>::fetch, conv<4, u8, CONVERT_MODE_4444UNORM>::write},			// FORMAT_BGRA4_UNORM
+				{conv<3, u8, CONVERT_MODE_565UNORM>::fetch, conv<3, u8, CONVERT_MODE_565UNORM>::write},				// FORMAT_R5G6B5_UNORM
+				{conv<3, u8, CONVERT_MODE_565UNORM>::fetch, conv<3, u8, CONVERT_MODE_565UNORM>::write},				// FORMAT_B5G6R5_UNORM
+				{conv<4, u8, CONVERT_MODE_5551UNORM>::fetch, conv<4, u8, CONVERT_MODE_5551UNORM>::write},			// FORMAT_RGB5A1_UNORM
+				{conv<4, u8, CONVERT_MODE_5551UNORM>::fetch, conv<4, u8, CONVERT_MODE_5551UNORM>::write},			// FORMAT_BGR5A1_UNORM
+				{conv<4, u8, CONVERT_MODE_5551UNORM>::fetch, conv<4, u8, CONVERT_MODE_5551UNORM>::write},			// FORMAT_A1RGB5_UNORM
 
-				{conv<u8, tvec1, CONVERT_MODE_NORM>::fetch, conv<u8, tvec1, CONVERT_MODE_NORM>::write},						// FORMAT_R8_UNORM
-				{conv<i8, tvec1, CONVERT_MODE_NORM>::fetch, conv<i8, tvec1, CONVERT_MODE_NORM>::write},						// FORMAT_R8_SNORM
-				{conv<u8, tvec1, CONVERT_MODE_CAST>::fetch, conv<u8, tvec1, CONVERT_MODE_CAST>::write},						// FORMAT_R8_USCALED
-				{conv<i8, tvec1, CONVERT_MODE_CAST>::fetch, conv<i8, tvec1, CONVERT_MODE_CAST>::write},						// FORMAT_R8_SSCALED
-				{conv<u8, tvec1, CONVERT_MODE_CAST>::fetch, conv<u8, tvec1, CONVERT_MODE_CAST>::write},						// FORMAT_R8_UINT
-				{conv<i8, tvec1, CONVERT_MODE_CAST>::fetch, conv<i8, tvec1, CONVERT_MODE_CAST>::write},						// FORMAT_R8_SINT
-				{conv<u8, tvec1, CONVERT_MODE_SRGB>::fetch, conv<u8, tvec1, CONVERT_MODE_SRGB>::write},						// FORMAT_R8_SRGB
+				{conv<1, u8, CONVERT_MODE_NORM>::fetch, conv<1, u8, CONVERT_MODE_NORM>::write},						// FORMAT_R8_UNORM
+				{conv<1, i8, CONVERT_MODE_NORM>::fetch, conv<1, i8, CONVERT_MODE_NORM>::write},						// FORMAT_R8_SNORM
+				{conv<1, u8, CONVERT_MODE_CAST>::fetch, conv<1, u8, CONVERT_MODE_CAST>::write},						// FORMAT_R8_USCALED
+				{conv<1, i8, CONVERT_MODE_CAST>::fetch, conv<1, i8, CONVERT_MODE_CAST>::write},						// FORMAT_R8_SSCALED
+				{conv<1, u8, CONVERT_MODE_CAST>::fetch, conv<1, u8, CONVERT_MODE_CAST>::write},						// FORMAT_R8_UINT
+				{conv<1, i8, CONVERT_MODE_CAST>::fetch, conv<1, i8, CONVERT_MODE_CAST>::write},						// FORMAT_R8_SINT
+				{conv<1, u8, CONVERT_MODE_SRGB>::fetch, conv<1, u8, CONVERT_MODE_SRGB>::write},						// FORMAT_R8_SRGB
 
-				{conv<u8, tvec2, CONVERT_MODE_NORM>::fetch, conv<u8, tvec2, CONVERT_MODE_NORM>::write},						// FORMAT_RG8_UNORM
-				{conv<i8, tvec2, CONVERT_MODE_NORM>::fetch, conv<i8, tvec2, CONVERT_MODE_NORM>::write},						// FORMAT_RG8_SNORM
-				{conv<u8, tvec2, CONVERT_MODE_CAST>::fetch, conv<u8, tvec2, CONVERT_MODE_CAST>::write},						// FORMAT_RG8_USCALED
-				{conv<i8, tvec2, CONVERT_MODE_CAST>::fetch, conv<i8, tvec2, CONVERT_MODE_CAST>::write},						// FORMAT_RG8_SSCALED
-				{conv<u8, tvec2, CONVERT_MODE_CAST>::fetch, conv<u8, tvec2, CONVERT_MODE_CAST>::write},						// FORMAT_RG8_UINT
-				{conv<i8, tvec2, CONVERT_MODE_CAST>::fetch, conv<i8, tvec2, CONVERT_MODE_CAST>::write},						// FORMAT_RG8_SINT
-				{conv<u8, tvec2, CONVERT_MODE_SRGB>::fetch, conv<u8, tvec2, CONVERT_MODE_SRGB>::write},						// FORMAT_RG8_SRGB
+				{conv<2, u8, CONVERT_MODE_NORM>::fetch, conv<2, u8, CONVERT_MODE_NORM>::write},						// FORMAT_RG8_UNORM
+				{conv<2, i8, CONVERT_MODE_NORM>::fetch, conv<2, i8, CONVERT_MODE_NORM>::write},						// FORMAT_RG8_SNORM
+				{conv<2, u8, CONVERT_MODE_CAST>::fetch, conv<2, u8, CONVERT_MODE_CAST>::write},						// FORMAT_RG8_USCALED
+				{conv<2, i8, CONVERT_MODE_CAST>::fetch, conv<2, i8, CONVERT_MODE_CAST>::write},						// FORMAT_RG8_SSCALED
+				{conv<2, u8, CONVERT_MODE_CAST>::fetch, conv<2, u8, CONVERT_MODE_CAST>::write},						// FORMAT_RG8_UINT
+				{conv<2, i8, CONVERT_MODE_CAST>::fetch, conv<2, i8, CONVERT_MODE_CAST>::write},						// FORMAT_RG8_SINT
+				{conv<2, u8, CONVERT_MODE_SRGB>::fetch, conv<2, u8, CONVERT_MODE_SRGB>::write},						// FORMAT_RG8_SRGB
 
-				{conv<u8, tvec3, CONVERT_MODE_NORM>::fetch, conv<u8, tvec3, CONVERT_MODE_NORM>::write},						// FORMAT_RGB8_UNORM
-				{conv<i8, tvec3, CONVERT_MODE_NORM>::fetch, conv<i8, tvec3, CONVERT_MODE_NORM>::write},						// FORMAT_RGB8_SNORM
-				{conv<u8, tvec3, CONVERT_MODE_CAST>::fetch, conv<u8, tvec3, CONVERT_MODE_CAST>::write},						// FORMAT_RGB8_USCALED
-				{conv<i8, tvec3, CONVERT_MODE_CAST>::fetch, conv<i8, tvec3, CONVERT_MODE_CAST>::write},						// FORMAT_RGB8_SSCALED
-				{conv<u8, tvec3, CONVERT_MODE_CAST>::fetch, conv<u8, tvec3, CONVERT_MODE_CAST>::write},						// FORMAT_RGB8_UINT
-				{conv<i8, tvec3, CONVERT_MODE_CAST>::fetch, conv<i8, tvec3, CONVERT_MODE_CAST>::write},						// FORMAT_RGB8_SINT
-				{conv<u8, tvec3, CONVERT_MODE_SRGB>::fetch, conv<u8, tvec3, CONVERT_MODE_SRGB>::write},						// FORMAT_RGB8_SRGB
+				{conv<3, u8, CONVERT_MODE_NORM>::fetch, conv<3, u8, CONVERT_MODE_NORM>::write},						// FORMAT_RGB8_UNORM
+				{conv<3, i8, CONVERT_MODE_NORM>::fetch, conv<3, i8, CONVERT_MODE_NORM>::write},						// FORMAT_RGB8_SNORM
+				{conv<3, u8, CONVERT_MODE_CAST>::fetch, conv<3, u8, CONVERT_MODE_CAST>::write},						// FORMAT_RGB8_USCALED
+				{conv<3, i8, CONVERT_MODE_CAST>::fetch, conv<3, i8, CONVERT_MODE_CAST>::write},						// FORMAT_RGB8_SSCALED
+				{conv<3, u8, CONVERT_MODE_CAST>::fetch, conv<3, u8, CONVERT_MODE_CAST>::write},						// FORMAT_RGB8_UINT
+				{conv<3, i8, CONVERT_MODE_CAST>::fetch, conv<3, i8, CONVERT_MODE_CAST>::write},						// FORMAT_RGB8_SINT
+				{conv<3, u8, CONVERT_MODE_SRGB>::fetch, conv<3, u8, CONVERT_MODE_SRGB>::write},						// FORMAT_RGB8_SRGB
 
-				{conv<u8, tvec3, CONVERT_MODE_NORM>::fetch, conv<u8, tvec3, CONVERT_MODE_NORM>::write},						// FORMAT_BGR8_UNORM
-				{conv<i8, tvec3, CONVERT_MODE_NORM>::fetch, conv<i8, tvec3, CONVERT_MODE_NORM>::write},						// FORMAT_BGR8_SNORM
-				{conv<u8, tvec3, CONVERT_MODE_CAST>::fetch, conv<u8, tvec3, CONVERT_MODE_CAST>::write},						// FORMAT_BGR8_USCALED
-				{conv<i8, tvec3, CONVERT_MODE_CAST>::fetch, conv<i8, tvec3, CONVERT_MODE_CAST>::write},						// FORMAT_BGR8_SSCALED
-				{conv<u32, tvec3, CONVERT_MODE_CAST>::fetch, conv<u32, tvec3, CONVERT_MODE_CAST>::write},					// FORMAT_BGR8_UINT
-				{conv<i32, tvec3, CONVERT_MODE_CAST>::fetch, conv<i32, tvec3, CONVERT_MODE_CAST>::write},					// FORMAT_BGR8_SINT
-				{conv<u8, tvec3, CONVERT_MODE_SRGB>::fetch, conv<u8, tvec3, CONVERT_MODE_SRGB>::write},						// FORMAT_BGR8_SRGB
+				{conv<3, u8, CONVERT_MODE_NORM>::fetch, conv<3, u8, CONVERT_MODE_NORM>::write},						// FORMAT_BGR8_UNORM
+				{conv<3, i8, CONVERT_MODE_NORM>::fetch, conv<3, i8, CONVERT_MODE_NORM>::write},						// FORMAT_BGR8_SNORM
+				{conv<3, u8, CONVERT_MODE_CAST>::fetch, conv<3, u8, CONVERT_MODE_CAST>::write},						// FORMAT_BGR8_USCALED
+				{conv<3, i8, CONVERT_MODE_CAST>::fetch, conv<3, i8, CONVERT_MODE_CAST>::write},						// FORMAT_BGR8_SSCALED
+				{conv<3, u32, CONVERT_MODE_CAST>::fetch, conv<3, u32, CONVERT_MODE_CAST>::write},					// FORMAT_BGR8_UINT
+				{conv<3, i32, CONVERT_MODE_CAST>::fetch, conv<3, i32, CONVERT_MODE_CAST>::write},					// FORMAT_BGR8_SINT
+				{conv<3, u8, CONVERT_MODE_SRGB>::fetch, conv<3, u8, CONVERT_MODE_SRGB>::write},						// FORMAT_BGR8_SRGB
 
-				{conv<u8, tvec4, CONVERT_MODE_NORM>::fetch, conv<u8, tvec4, CONVERT_MODE_NORM>::write},						// FORMAT_RGBA8_UNORM
-				{conv<i8, tvec4, CONVERT_MODE_NORM>::fetch, conv<i8, tvec4, CONVERT_MODE_NORM>::write},						// FORMAT_RGBA8_SNORM
-				{conv<u8, tvec4, CONVERT_MODE_CAST>::fetch, conv<u8, tvec4, CONVERT_MODE_CAST>::write},						// FORMAT_RGBA8_USCALED
-				{conv<i8, tvec4, CONVERT_MODE_CAST>::fetch, conv<i8, tvec4, CONVERT_MODE_CAST>::write},						// FORMAT_RGBA8_SSCALED
-				{conv<u8, tvec4, CONVERT_MODE_CAST>::fetch, conv<u8, tvec4, CONVERT_MODE_CAST>::write},						// FORMAT_RGBA8_UINT
-				{conv<i8, tvec4, CONVERT_MODE_CAST>::fetch, conv<i8, tvec4, CONVERT_MODE_CAST>::write},						// FORMAT_RGBA8_SINT
-				{conv<u8, tvec4, CONVERT_MODE_SRGB>::fetch, conv<u8, tvec4, CONVERT_MODE_SRGB>::write},						// FORMAT_RGBA8_SRGB
+				{conv<4, u8, CONVERT_MODE_NORM>::fetch, conv<4, u8, CONVERT_MODE_NORM>::write},						// FORMAT_RGBA8_UNORM
+				{conv<4, i8, CONVERT_MODE_NORM>::fetch, conv<4, i8, CONVERT_MODE_NORM>::write},						// FORMAT_RGBA8_SNORM
+				{conv<4, u8, CONVERT_MODE_CAST>::fetch, conv<4, u8, CONVERT_MODE_CAST>::write},						// FORMAT_RGBA8_USCALED
+				{conv<4, i8, CONVERT_MODE_CAST>::fetch, conv<4, i8, CONVERT_MODE_CAST>::write},						// FORMAT_RGBA8_SSCALED
+				{conv<4, u8, CONVERT_MODE_CAST>::fetch, conv<4, u8, CONVERT_MODE_CAST>::write},						// FORMAT_RGBA8_UINT
+				{conv<4, i8, CONVERT_MODE_CAST>::fetch, conv<4, i8, CONVERT_MODE_CAST>::write},						// FORMAT_RGBA8_SINT
+				{conv<4, u8, CONVERT_MODE_SRGB>::fetch, conv<4, u8, CONVERT_MODE_SRGB>::write},						// FORMAT_RGBA8_SRGB
 
-				{conv<u8, tvec4, CONVERT_MODE_NORM>::fetch, conv<u8, tvec4, CONVERT_MODE_NORM>::write},						// FORMAT_BGRA8_UNORM
-				{conv<i8, tvec4, CONVERT_MODE_NORM>::fetch, conv<i8, tvec4, CONVERT_MODE_NORM>::write},						// FORMAT_BGRA8_SNORM
-				{conv<u8, tvec4, CONVERT_MODE_CAST>::fetch, conv<u8, tvec4, CONVERT_MODE_CAST>::write},						// FORMAT_BGRA8_USCALED
-				{conv<i8, tvec4, CONVERT_MODE_CAST>::fetch, conv<i8, tvec4, CONVERT_MODE_CAST>::write},						// FORMAT_BGRA8_SSCALED
-				{conv<u8, tvec4, CONVERT_MODE_CAST>::fetch, conv<u8, tvec4, CONVERT_MODE_CAST>::write},						// FORMAT_BGRA8_UINT
-				{conv<i8, tvec4, CONVERT_MODE_CAST>::fetch, conv<i8, tvec4, CONVERT_MODE_CAST>::write},						// FORMAT_BGRA8_SINT
-				{conv<u8, tvec4, CONVERT_MODE_SRGB>::fetch, conv<u8, tvec4, CONVERT_MODE_SRGB>::write},						// FORMAT_BGRA8_SRGB
+				{conv<4, u8, CONVERT_MODE_NORM>::fetch, conv<4, u8, CONVERT_MODE_NORM>::write},						// FORMAT_BGRA8_UNORM
+				{conv<4, i8, CONVERT_MODE_NORM>::fetch, conv<4, i8, CONVERT_MODE_NORM>::write},						// FORMAT_BGRA8_SNORM
+				{conv<4, u8, CONVERT_MODE_CAST>::fetch, conv<4, u8, CONVERT_MODE_CAST>::write},						// FORMAT_BGRA8_USCALED
+				{conv<4, i8, CONVERT_MODE_CAST>::fetch, conv<4, i8, CONVERT_MODE_CAST>::write},						// FORMAT_BGRA8_SSCALED
+				{conv<4, u8, CONVERT_MODE_CAST>::fetch, conv<4, u8, CONVERT_MODE_CAST>::write},						// FORMAT_BGRA8_UINT
+				{conv<4, i8, CONVERT_MODE_CAST>::fetch, conv<4, i8, CONVERT_MODE_CAST>::write},						// FORMAT_BGRA8_SINT
+				{conv<4, u8, CONVERT_MODE_SRGB>::fetch, conv<4, u8, CONVERT_MODE_SRGB>::write},						// FORMAT_BGRA8_SRGB
 
-				{conv<u8, tvec4, CONVERT_MODE_NORM>::fetch, conv<u8, tvec4, CONVERT_MODE_NORM>::write},						// FORMAT_ABGR8_UNORM
-				{conv<i8, tvec4, CONVERT_MODE_NORM>::fetch, conv<i8, tvec4, CONVERT_MODE_NORM>::write},						// FORMAT_ABGR8_SNORM
-				{conv<u8, tvec4, CONVERT_MODE_CAST>::fetch, conv<u8, tvec4, CONVERT_MODE_CAST>::write},						// FORMAT_ABGR8_USCALED
-				{conv<i8, tvec4, CONVERT_MODE_CAST>::fetch, conv<i8, tvec4, CONVERT_MODE_CAST>::write},						// FORMAT_ABGR8_SSCALED
-				{conv<u8, tvec4, CONVERT_MODE_CAST>::fetch, conv<u8, tvec4, CONVERT_MODE_CAST>::write},						// FORMAT_ABGR8_UINT
-				{conv<i8, tvec4, CONVERT_MODE_CAST>::fetch, conv<i8, tvec4, CONVERT_MODE_CAST>::write},						// FORMAT_ABGR8_SINT
-				{conv<u8, tvec4, CONVERT_MODE_SRGB>::fetch, conv<u8, tvec4, CONVERT_MODE_SRGB>::write},						// FORMAT_ABGR8_SRGB
+				{conv<4, u8, CONVERT_MODE_NORM>::fetch, conv<4, u8, CONVERT_MODE_NORM>::write},						// FORMAT_ABGR8_UNORM
+				{conv<4, i8, CONVERT_MODE_NORM>::fetch, conv<4, i8, CONVERT_MODE_NORM>::write},						// FORMAT_ABGR8_SNORM
+				{conv<4, u8, CONVERT_MODE_CAST>::fetch, conv<4, u8, CONVERT_MODE_CAST>::write},						// FORMAT_ABGR8_USCALED
+				{conv<4, i8, CONVERT_MODE_CAST>::fetch, conv<4, i8, CONVERT_MODE_CAST>::write},						// FORMAT_ABGR8_SSCALED
+				{conv<4, u8, CONVERT_MODE_CAST>::fetch, conv<4, u8, CONVERT_MODE_CAST>::write},						// FORMAT_ABGR8_UINT
+				{conv<4, i8, CONVERT_MODE_CAST>::fetch, conv<4, i8, CONVERT_MODE_CAST>::write},						// FORMAT_ABGR8_SINT
+				{conv<4, u8, CONVERT_MODE_SRGB>::fetch, conv<4, u8, CONVERT_MODE_SRGB>::write},						// FORMAT_ABGR8_SRGB
 
-				{conv<u8, tvec4, CONVERT_MODE_RGB10A2UNORM>::fetch, conv<u8, tvec4, CONVERT_MODE_RGB10A2UNORM>::write},		// FORMAT_RGB10A2_UNORM
-				{conv<i8, tvec4, CONVERT_MODE_RGB10A2SNORM>::fetch, conv<i8, tvec4, CONVERT_MODE_RGB10A2SNORM>::write},		// FORMAT_RGB10A2_SNORM
-				{conv<u8, tvec4, CONVERT_MODE_RGB10A2USCALE>::fetch, conv<u8, tvec4, CONVERT_MODE_RGB10A2USCALE>::write},	// FORMAT_RGB10A2_USCALED
-				{conv<i8, tvec4, CONVERT_MODE_RGB10A2SSCALE>::fetch, conv<i8, tvec4, CONVERT_MODE_RGB10A2SSCALE>::write},	// FORMAT_RGB10A2_SSCALED
-				{conv<u8, tvec4, CONVERT_MODE_RGB10A2UINT>::fetch, conv<u8, tvec4, CONVERT_MODE_RGB10A2UINT>::write},		// FORMAT_RGB10A2_UINT
-				{conv<i8, tvec4, CONVERT_MODE_RGB10A2SINT>::fetch, conv<i8, tvec4, CONVERT_MODE_RGB10A2SINT>::write},		// FORMAT_RGB10A2_SINT
+				{conv<4, u8, CONVERT_MODE_RGB10A2UNORM>::fetch, conv<4, u8, CONVERT_MODE_RGB10A2UNORM>::write},		// FORMAT_RGB10A2_UNORM
+				{conv<4, i8, CONVERT_MODE_RGB10A2SNORM>::fetch, conv<4, i8, CONVERT_MODE_RGB10A2SNORM>::write},		// FORMAT_RGB10A2_SNORM
+				{conv<4, u8, CONVERT_MODE_RGB10A2USCALE>::fetch, conv<4, u8, CONVERT_MODE_RGB10A2USCALE>::write},	// FORMAT_RGB10A2_USCALED
+				{conv<4, i8, CONVERT_MODE_RGB10A2SSCALE>::fetch, conv<4, i8, CONVERT_MODE_RGB10A2SSCALE>::write},	// FORMAT_RGB10A2_SSCALED
+				{conv<4, u8, CONVERT_MODE_RGB10A2UINT>::fetch, conv<4, u8, CONVERT_MODE_RGB10A2UINT>::write},		// FORMAT_RGB10A2_UINT
+				{conv<4, i8, CONVERT_MODE_RGB10A2SINT>::fetch, conv<4, i8, CONVERT_MODE_RGB10A2SINT>::write},		// FORMAT_RGB10A2_SINT
 
-				{conv<u8, tvec4, CONVERT_MODE_RGB10A2UNORM>::fetch, conv<u8, tvec4, CONVERT_MODE_RGB10A2UNORM>::write},		// FORMAT_BGR10A2_UNORM
-				{conv<i8, tvec4, CONVERT_MODE_RGB10A2SNORM>::fetch, conv<i8, tvec4, CONVERT_MODE_RGB10A2SNORM>::write},		// FORMAT_BGR10A2_SNORM
-				{conv<u8, tvec4, CONVERT_MODE_RGB10A2USCALE>::fetch, conv<u8, tvec4, CONVERT_MODE_RGB10A2USCALE>::write},	// FORMAT_BGR10A2_USCALED
-				{conv<i8, tvec4, CONVERT_MODE_RGB10A2SSCALE>::fetch, conv<i8, tvec4, CONVERT_MODE_RGB10A2SSCALE>::write},	// FORMAT_BGR10A2_SSCALED
-				{conv<u8, tvec4, CONVERT_MODE_RGB10A2UINT>::fetch, conv<u8, tvec4, CONVERT_MODE_RGB10A2UINT>::write},		// FORMAT_BGR10A2_UINT
-				{conv<i8, tvec4, CONVERT_MODE_RGB10A2SINT>::fetch, conv<i8, tvec4, CONVERT_MODE_RGB10A2SINT>::write},		// FORMAT_BGR10A2_SINT
+				{conv<4, u8, CONVERT_MODE_RGB10A2UNORM>::fetch, conv<4, u8, CONVERT_MODE_RGB10A2UNORM>::write},		// FORMAT_BGR10A2_UNORM
+				{conv<4, i8, CONVERT_MODE_RGB10A2SNORM>::fetch, conv<4, i8, CONVERT_MODE_RGB10A2SNORM>::write},		// FORMAT_BGR10A2_SNORM
+				{conv<4, u8, CONVERT_MODE_RGB10A2USCALE>::fetch, conv<4, u8, CONVERT_MODE_RGB10A2USCALE>::write},	// FORMAT_BGR10A2_USCALED
+				{conv<4, i8, CONVERT_MODE_RGB10A2SSCALE>::fetch, conv<4, i8, CONVERT_MODE_RGB10A2SSCALE>::write},	// FORMAT_BGR10A2_SSCALED
+				{conv<4, u8, CONVERT_MODE_RGB10A2UINT>::fetch, conv<4, u8, CONVERT_MODE_RGB10A2UINT>::write},		// FORMAT_BGR10A2_UINT
+				{conv<4, i8, CONVERT_MODE_RGB10A2SINT>::fetch, conv<4, i8, CONVERT_MODE_RGB10A2SINT>::write},		// FORMAT_BGR10A2_SINT
 
-				{conv<u16, tvec1, CONVERT_MODE_NORM>::fetch, conv<u16, tvec1, CONVERT_MODE_NORM>::write},					// FORMAT_R16_UNORM_PACK16
-				{conv<i16, tvec1, CONVERT_MODE_NORM>::fetch, conv<i16, tvec1, CONVERT_MODE_NORM>::write},					// FORMAT_R16_SNORM_PACK16
-				{conv<u16, tvec1, CONVERT_MODE_CAST>::fetch, conv<u16, tvec1, CONVERT_MODE_CAST>::write},					// FORMAT_R16_USCALED_PACK16
-				{conv<i16, tvec1, CONVERT_MODE_CAST>::fetch, conv<i16, tvec1, CONVERT_MODE_CAST>::write},					// FORMAT_R16_SSCALED_PACK16
-				{conv<u16, tvec1, CONVERT_MODE_CAST>::fetch, conv<u16, tvec1, CONVERT_MODE_CAST>::write},					// FORMAT_R16_UINT_PACK16
-				{conv<i16, tvec1, CONVERT_MODE_CAST>::fetch, conv<i16, tvec1, CONVERT_MODE_CAST>::write},					// FORMAT_R16_SINT_PACK16
-				{conv<u16, tvec1, CONVERT_MODE_HALF>::fetch, conv<u16, tvec1, CONVERT_MODE_HALF>::write},					// FORMAT_R16_SFLOAT_PACK16
+				{conv<1, u16, CONVERT_MODE_NORM>::fetch, conv<1, u16, CONVERT_MODE_NORM>::write},					// FORMAT_R16_UNORM_PACK16
+				{conv<1, i16, CONVERT_MODE_NORM>::fetch, conv<1, i16, CONVERT_MODE_NORM>::write},					// FORMAT_R16_SNORM_PACK16
+				{conv<1, u16, CONVERT_MODE_CAST>::fetch, conv<1, u16, CONVERT_MODE_CAST>::write},					// FORMAT_R16_USCALED_PACK16
+				{conv<1, i16, CONVERT_MODE_CAST>::fetch, conv<1, i16, CONVERT_MODE_CAST>::write},					// FORMAT_R16_SSCALED_PACK16
+				{conv<1, u16, CONVERT_MODE_CAST>::fetch, conv<1, u16, CONVERT_MODE_CAST>::write},					// FORMAT_R16_UINT_PACK16
+				{conv<1, i16, CONVERT_MODE_CAST>::fetch, conv<1, i16, CONVERT_MODE_CAST>::write},					// FORMAT_R16_SINT_PACK16
+				{conv<1, u16, CONVERT_MODE_HALF>::fetch, conv<1, u16, CONVERT_MODE_HALF>::write},					// FORMAT_R16_SFLOAT_PACK16
 
-				{conv<u16, tvec2, CONVERT_MODE_NORM>::fetch, conv<u16, tvec2, CONVERT_MODE_NORM>::write},					// FORMAT_RG16_UNORM_PACK16
-				{conv<i16, tvec2, CONVERT_MODE_NORM>::fetch, conv<i16, tvec2, CONVERT_MODE_NORM>::write},					// FORMAT_RG16_SNORM_PACK16
-				{conv<u16, tvec2, CONVERT_MODE_CAST>::fetch, conv<u16, tvec2, CONVERT_MODE_CAST>::write},					// FORMAT_RG16_USCALED_PACK16
-				{conv<i16, tvec2, CONVERT_MODE_CAST>::fetch, conv<i16, tvec2, CONVERT_MODE_CAST>::write},					// FORMAT_RG16_SSCALED_PACK16
-				{conv<u16, tvec2, CONVERT_MODE_CAST>::fetch, conv<u16, tvec2, CONVERT_MODE_CAST>::write},					// FORMAT_RG16_UINT_PACK16
-				{conv<i16, tvec2, CONVERT_MODE_CAST>::fetch, conv<i16, tvec2, CONVERT_MODE_CAST>::write},					// FORMAT_RG16_SINT_PACK16
-				{conv<u16, tvec2, CONVERT_MODE_HALF>::fetch, conv<u16, tvec2, CONVERT_MODE_HALF>::write},					// FORMAT_RG16_SFLOAT_PACK16
+				{conv<2, u16, CONVERT_MODE_NORM>::fetch, conv<2, u16, CONVERT_MODE_NORM>::write},					// FORMAT_RG16_UNORM_PACK16
+				{conv<2, i16, CONVERT_MODE_NORM>::fetch, conv<2, i16, CONVERT_MODE_NORM>::write},					// FORMAT_RG16_SNORM_PACK16
+				{conv<2, u16, CONVERT_MODE_CAST>::fetch, conv<2, u16, CONVERT_MODE_CAST>::write},					// FORMAT_RG16_USCALED_PACK16
+				{conv<2, i16, CONVERT_MODE_CAST>::fetch, conv<2, i16, CONVERT_MODE_CAST>::write},					// FORMAT_RG16_SSCALED_PACK16
+				{conv<2, u16, CONVERT_MODE_CAST>::fetch, conv<2, u16, CONVERT_MODE_CAST>::write},					// FORMAT_RG16_UINT_PACK16
+				{conv<2, i16, CONVERT_MODE_CAST>::fetch, conv<2, i16, CONVERT_MODE_CAST>::write},					// FORMAT_RG16_SINT_PACK16
+				{conv<2, u16, CONVERT_MODE_HALF>::fetch, conv<2, u16, CONVERT_MODE_HALF>::write},					// FORMAT_RG16_SFLOAT_PACK16
 
-				{conv<u16, tvec3, CONVERT_MODE_NORM>::fetch, conv<u16, tvec3, CONVERT_MODE_NORM>::write},					// FORMAT_RGB16_UNORM_PACK16
-				{conv<i16, tvec3, CONVERT_MODE_NORM>::fetch, conv<i16, tvec3, CONVERT_MODE_NORM>::write},					// FORMAT_RGB16_SNORM_PACK16
-				{conv<u16, tvec3, CONVERT_MODE_CAST>::fetch, conv<u16, tvec3, CONVERT_MODE_CAST>::write},					// FORMAT_RGB16_USCALED_PACK16
-				{conv<i16, tvec3, CONVERT_MODE_CAST>::fetch, conv<i16, tvec3, CONVERT_MODE_CAST>::write},					// FORMAT_RGB16_SSCALED_PACK16
-				{conv<u16, tvec3, CONVERT_MODE_CAST>::fetch, conv<u16, tvec3, CONVERT_MODE_CAST>::write},					// FORMAT_RGB16_UINT_PACK16
-				{conv<i16, tvec3, CONVERT_MODE_CAST>::fetch, conv<i16, tvec3, CONVERT_MODE_CAST>::write},					// FORMAT_RGB16_SINT_PACK16
-				{conv<u16, tvec3, CONVERT_MODE_HALF>::fetch, conv<u16, tvec3, CONVERT_MODE_HALF>::write},					// FORMAT_RGB16_SFLOAT_PACK16
+				{conv<3, u16, CONVERT_MODE_NORM>::fetch, conv<3, u16, CONVERT_MODE_NORM>::write},					// FORMAT_RGB16_UNORM_PACK16
+				{conv<3, i16, CONVERT_MODE_NORM>::fetch, conv<3, i16, CONVERT_MODE_NORM>::write},					// FORMAT_RGB16_SNORM_PACK16
+				{conv<3, u16, CONVERT_MODE_CAST>::fetch, conv<3, u16, CONVERT_MODE_CAST>::write},					// FORMAT_RGB16_USCALED_PACK16
+				{conv<3, i16, CONVERT_MODE_CAST>::fetch, conv<3, i16, CONVERT_MODE_CAST>::write},					// FORMAT_RGB16_SSCALED_PACK16
+				{conv<3, u16, CONVERT_MODE_CAST>::fetch, conv<3, u16, CONVERT_MODE_CAST>::write},					// FORMAT_RGB16_UINT_PACK16
+				{conv<3, i16, CONVERT_MODE_CAST>::fetch, conv<3, i16, CONVERT_MODE_CAST>::write},					// FORMAT_RGB16_SINT_PACK16
+				{conv<3, u16, CONVERT_MODE_HALF>::fetch, conv<3, u16, CONVERT_MODE_HALF>::write},					// FORMAT_RGB16_SFLOAT_PACK16
 
-				{conv<u16, tvec4, CONVERT_MODE_NORM>::fetch, conv<u16, tvec4, CONVERT_MODE_NORM>::write},					// FORMAT_RGBA16_UNORM_PACK16
-				{conv<i16, tvec4, CONVERT_MODE_NORM>::fetch, conv<i16, tvec4, CONVERT_MODE_NORM>::write},					// FORMAT_RGBA16_SNORM_PACK16
-				{conv<u16, tvec4, CONVERT_MODE_CAST>::fetch, conv<u16, tvec4, CONVERT_MODE_CAST>::write},					// FORMAT_RGBA16_USCALED_PACK16
-				{conv<i16, tvec4, CONVERT_MODE_CAST>::fetch, conv<i16, tvec4, CONVERT_MODE_CAST>::write},					// FORMAT_RGBA16_SSCALED_PACK16
-				{conv<u16, tvec4, CONVERT_MODE_CAST>::fetch, conv<u16, tvec4, CONVERT_MODE_CAST>::write},					// FORMAT_RGBA16_UINT_PACK16
-				{conv<i16, tvec4, CONVERT_MODE_CAST>::fetch, conv<i16, tvec4, CONVERT_MODE_CAST>::write},					// FORMAT_RGBA16_SINT_PACK16
-				{conv<u16, tvec4, CONVERT_MODE_HALF>::fetch, conv<u16, tvec4, CONVERT_MODE_HALF>::write},					// FORMAT_RGBA16_SFLOAT_PACK16
+				{conv<4, u16, CONVERT_MODE_NORM>::fetch, conv<4, u16, CONVERT_MODE_NORM>::write},					// FORMAT_RGBA16_UNORM_PACK16
+				{conv<4, i16, CONVERT_MODE_NORM>::fetch, conv<4, i16, CONVERT_MODE_NORM>::write},					// FORMAT_RGBA16_SNORM_PACK16
+				{conv<4, u16, CONVERT_MODE_CAST>::fetch, conv<4, u16, CONVERT_MODE_CAST>::write},					// FORMAT_RGBA16_USCALED_PACK16
+				{conv<4, i16, CONVERT_MODE_CAST>::fetch, conv<4, i16, CONVERT_MODE_CAST>::write},					// FORMAT_RGBA16_SSCALED_PACK16
+				{conv<4, u16, CONVERT_MODE_CAST>::fetch, conv<4, u16, CONVERT_MODE_CAST>::write},					// FORMAT_RGBA16_UINT_PACK16
+				{conv<4, i16, CONVERT_MODE_CAST>::fetch, conv<4, i16, CONVERT_MODE_CAST>::write},					// FORMAT_RGBA16_SINT_PACK16
+				{conv<4, u16, CONVERT_MODE_HALF>::fetch, conv<4, u16, CONVERT_MODE_HALF>::write},					// FORMAT_RGBA16_SFLOAT_PACK16
 
-				{conv<u32, tvec1, CONVERT_MODE_CAST>::fetch, conv<u32, tvec1, CONVERT_MODE_CAST>::write},					// FORMAT_R32_UINT_PACK32
-				{conv<i32, tvec1, CONVERT_MODE_CAST>::fetch, conv<i32, tvec1, CONVERT_MODE_CAST>::write},					// FORMAT_R32_SINT_PACK32
-				{conv<f32, tvec1, CONVERT_MODE_CAST>::fetch, conv<f32, tvec1, CONVERT_MODE_CAST>::write},					// FORMAT_R32_SFLOAT_PACK32
+				{conv<1, u32, CONVERT_MODE_CAST>::fetch, conv<1, u32, CONVERT_MODE_CAST>::write},					// FORMAT_R32_UINT_PACK32
+				{conv<1, i32, CONVERT_MODE_CAST>::fetch, conv<1, i32, CONVERT_MODE_CAST>::write},					// FORMAT_R32_SINT_PACK32
+				{conv<1, f32, CONVERT_MODE_CAST>::fetch, conv<1, f32, CONVERT_MODE_CAST>::write},					// FORMAT_R32_SFLOAT_PACK32
 
-				{conv<u32, tvec2, CONVERT_MODE_CAST>::fetch, conv<u32, tvec2, CONVERT_MODE_CAST>::write},					// FORMAT_RG32_UINT_PACK32
-				{conv<i32, tvec2, CONVERT_MODE_CAST>::fetch, conv<i32, tvec2, CONVERT_MODE_CAST>::write},					// FORMAT_RG32_SINT_PACK32
-				{conv<f32, tvec2, CONVERT_MODE_CAST>::fetch, conv<f32, tvec2, CONVERT_MODE_CAST>::write},					// FORMAT_RG32_SFLOAT_PACK32
+				{conv<2, u32, CONVERT_MODE_CAST>::fetch, conv<2, u32, CONVERT_MODE_CAST>::write},					// FORMAT_RG32_UINT_PACK32
+				{conv<2, i32, CONVERT_MODE_CAST>::fetch, conv<2, i32, CONVERT_MODE_CAST>::write},					// FORMAT_RG32_SINT_PACK32
+				{conv<2, f32, CONVERT_MODE_CAST>::fetch, conv<2, f32, CONVERT_MODE_CAST>::write},					// FORMAT_RG32_SFLOAT_PACK32
 
-				{conv<u32, tvec3, CONVERT_MODE_CAST>::fetch, conv<u32, tvec3, CONVERT_MODE_CAST>::write},					// FORMAT_RGB32_UINT_PACK32
-				{conv<i32, tvec3, CONVERT_MODE_CAST>::fetch, conv<i32, tvec3, CONVERT_MODE_CAST>::write},					// FORMAT_RGB32_SINT_PACK32
-				{conv<f32, tvec3, CONVERT_MODE_CAST>::fetch, conv<f32, tvec3, CONVERT_MODE_CAST>::write},					// FORMAT_RGB32_SFLOAT_PACK32
+				{conv<3, u32, CONVERT_MODE_CAST>::fetch, conv<3, u32, CONVERT_MODE_CAST>::write},					// FORMAT_RGB32_UINT_PACK32
+				{conv<3, i32, CONVERT_MODE_CAST>::fetch, conv<3, i32, CONVERT_MODE_CAST>::write},					// FORMAT_RGB32_SINT_PACK32
+				{conv<3, f32, CONVERT_MODE_CAST>::fetch, conv<3, f32, CONVERT_MODE_CAST>::write},					// FORMAT_RGB32_SFLOAT_PACK32
 
-				{conv<u32, tvec4, CONVERT_MODE_CAST>::fetch, conv<u32, tvec4, CONVERT_MODE_CAST>::write},					// FORMAT_RGBA32_UINT_PACK32
-				{conv<i32, tvec4, CONVERT_MODE_CAST>::fetch, conv<i32, tvec4, CONVERT_MODE_CAST>::write},					// FORMAT_RGBA32_SINT_PACK32
-				{conv<f32, tvec4, CONVERT_MODE_CAST>::fetch, conv<f32, tvec4, CONVERT_MODE_CAST>::write},					// FORMAT_RGBA32_SFLOAT_PACK32
+				{conv<4, u32, CONVERT_MODE_CAST>::fetch, conv<4, u32, CONVERT_MODE_CAST>::write},					// FORMAT_RGBA32_UINT_PACK32
+				{conv<4, i32, CONVERT_MODE_CAST>::fetch, conv<4, i32, CONVERT_MODE_CAST>::write},					// FORMAT_RGBA32_SINT_PACK32
+				{conv<4, f32, CONVERT_MODE_CAST>::fetch, conv<4, f32, CONVERT_MODE_CAST>::write},					// FORMAT_RGBA32_SFLOAT_PACK32
 
-				{conv<u64, tvec1, CONVERT_MODE_CAST>::fetch, conv<u64, tvec1, CONVERT_MODE_CAST>::write},					// FORMAT_R64_UINT_PACK64
-				{conv<i64, tvec1, CONVERT_MODE_CAST>::fetch, conv<i64, tvec1, CONVERT_MODE_CAST>::write},					// FORMAT_R64_SINT_PACK64
-				{conv<f64, tvec1, CONVERT_MODE_CAST>::fetch, conv<f64, tvec1, CONVERT_MODE_CAST>::write},					// FORMAT_R64_SFLOAT_PACK64
+				{conv<1, u64, CONVERT_MODE_CAST>::fetch, conv<1, u64, CONVERT_MODE_CAST>::write},					// FORMAT_R64_UINT_PACK64
+				{conv<1, i64, CONVERT_MODE_CAST>::fetch, conv<1, i64, CONVERT_MODE_CAST>::write},					// FORMAT_R64_SINT_PACK64
+				{conv<1, f64, CONVERT_MODE_CAST>::fetch, conv<1, f64, CONVERT_MODE_CAST>::write},					// FORMAT_R64_SFLOAT_PACK64
 
-				{conv<u64, tvec2, CONVERT_MODE_CAST>::fetch, conv<u64, tvec2, CONVERT_MODE_CAST>::write},					// FORMAT_RG64_UINT_PACK64
-				{conv<i64, tvec2, CONVERT_MODE_CAST>::fetch, conv<i64, tvec2, CONVERT_MODE_CAST>::write},					// FORMAT_RG64_SINT_PACK64
-				{conv<f64, tvec2, CONVERT_MODE_CAST>::fetch, conv<f64, tvec2, CONVERT_MODE_CAST>::write},					// FORMAT_RG64_SFLOAT_PACK64
+				{conv<2, u64, CONVERT_MODE_CAST>::fetch, conv<2, u64, CONVERT_MODE_CAST>::write},					// FORMAT_RG64_UINT_PACK64
+				{conv<2, i64, CONVERT_MODE_CAST>::fetch, conv<2, i64, CONVERT_MODE_CAST>::write},					// FORMAT_RG64_SINT_PACK64
+				{conv<2, f64, CONVERT_MODE_CAST>::fetch, conv<2, f64, CONVERT_MODE_CAST>::write},					// FORMAT_RG64_SFLOAT_PACK64
 
-				{conv<u64, tvec3, CONVERT_MODE_CAST>::fetch, conv<u64, tvec3, CONVERT_MODE_CAST>::write},					// FORMAT_RGB64_UINT_PACK64
-				{conv<i64, tvec3, CONVERT_MODE_CAST>::fetch, conv<i64, tvec3, CONVERT_MODE_CAST>::write},					// FORMAT_RGB64_SINT_PACK64
-				{conv<f64, tvec3, CONVERT_MODE_CAST>::fetch, conv<f64, tvec3, CONVERT_MODE_CAST>::write},					// FORMAT_RGB64_SFLOAT_PACK64
+				{conv<3, u64, CONVERT_MODE_CAST>::fetch, conv<3, u64, CONVERT_MODE_CAST>::write},					// FORMAT_RGB64_UINT_PACK64
+				{conv<3, i64, CONVERT_MODE_CAST>::fetch, conv<3, i64, CONVERT_MODE_CAST>::write},					// FORMAT_RGB64_SINT_PACK64
+				{conv<3, f64, CONVERT_MODE_CAST>::fetch, conv<3, f64, CONVERT_MODE_CAST>::write},					// FORMAT_RGB64_SFLOAT_PACK64
 
-				{conv<u64, tvec4, CONVERT_MODE_CAST>::fetch, conv<u64, tvec4, CONVERT_MODE_CAST>::write},					// FORMAT_RGBA64_UINT_PACK64
-				{conv<i64, tvec4, CONVERT_MODE_CAST>::fetch, conv<i64, tvec4, CONVERT_MODE_CAST>::write},					// FORMAT_RGBA64_SINT_PACK64
-				{conv<f64, tvec4, CONVERT_MODE_CAST>::fetch, conv<f64, tvec4, CONVERT_MODE_CAST>::write},					// FORMAT_RGBA64_SFLOAT_PACK64
+				{conv<4, u64, CONVERT_MODE_CAST>::fetch, conv<4, u64, CONVERT_MODE_CAST>::write},					// FORMAT_RGBA64_UINT_PACK64
+				{conv<4, i64, CONVERT_MODE_CAST>::fetch, conv<4, i64, CONVERT_MODE_CAST>::write},					// FORMAT_RGBA64_SINT_PACK64
+				{conv<4, f64, CONVERT_MODE_CAST>::fetch, conv<4, f64, CONVERT_MODE_CAST>::write},					// FORMAT_RGBA64_SFLOAT_PACK64
 
-				{conv<u32, tvec1, CONVERT_MODE_RG11B10F>::fetch, conv<u32, tvec1, CONVERT_MODE_RG11B10F>::write},			// FORMAT_RG11B10_UFLOAT
-				{conv<u32, tvec1, CONVERT_MODE_RGB9E5>::fetch, conv<u32, tvec1, CONVERT_MODE_RGB9E5>::write},				// FORMAT_RGB9E5_UFLOAT
+				{conv<1, u32, CONVERT_MODE_RG11B10F>::fetch, conv<1, u32, CONVERT_MODE_RG11B10F>::write},			// FORMAT_RG11B10_UFLOAT
+				{conv<1, u32, CONVERT_MODE_RGB9E5>::fetch, conv<1, u32, CONVERT_MODE_RGB9E5>::write},				// FORMAT_RGB9E5_UFLOAT
 
-				{conv<u16, tvec1, CONVERT_MODE_DEFAULT>::fetch, conv<u16, tvec1, CONVERT_MODE_DEFAULT>::write},				// FORMAT_D16_UNORM_PACK16
-				{conv<u32, tvec1, CONVERT_MODE_DEFAULT>::fetch, conv<u32, tvec1, CONVERT_MODE_DEFAULT>::write},				// FORMAT_D24_UNORM
-				{conv<float, tvec1, CONVERT_MODE_DEFAULT>::fetch, conv<float, tvec1, CONVERT_MODE_DEFAULT>::write},			// FORMAT_D32_SFLOAT_PACK32
-				{conv<u8, tvec1, CONVERT_MODE_DEFAULT>::fetch, conv<u8, tvec1, CONVERT_MODE_DEFAULT>::write},				// FORMAT_S8_UINT_PACK8
-				{conv<u16, tvec2, CONVERT_MODE_DEFAULT>::fetch, conv<u16, tvec2, CONVERT_MODE_DEFAULT>::write},				// FORMAT_D16_UNORM_S8_UINT_PACK32
-				{conv<u32, tvec2, CONVERT_MODE_DEFAULT>::fetch, conv<u32, tvec2, CONVERT_MODE_DEFAULT>::write},				// FORMAT_D24_UNORM_S8_UINT_PACK32
-				{conv<u32, tvec2, CONVERT_MODE_DEFAULT>::fetch, conv<u32, tvec2, CONVERT_MODE_DEFAULT>::write},				// FORMAT_D32_SFLOAT_S8_UINT_PACK64
+				{conv<1, u16, CONVERT_MODE_DEFAULT>::fetch, conv<1, u16, CONVERT_MODE_DEFAULT>::write},				// FORMAT_D16_UNORM_PACK16
+				{conv<1, u32, CONVERT_MODE_DEFAULT>::fetch, conv<1, u32, CONVERT_MODE_DEFAULT>::write},				// FORMAT_D24_UNORM
+				{conv<1, f32, CONVERT_MODE_DEFAULT>::fetch, conv<1, f32, CONVERT_MODE_DEFAULT>::write},				// FORMAT_D32_SFLOAT_PACK32
+				{conv<1, u8, CONVERT_MODE_DEFAULT>::fetch, conv<1, u8, CONVERT_MODE_DEFAULT>::write},				// FORMAT_S8_UINT_PACK8
+				{conv<2, u16, CONVERT_MODE_DEFAULT>::fetch, conv<2, u16, CONVERT_MODE_DEFAULT>::write},				// FORMAT_D16_UNORM_S8_UINT_PACK32
+				{conv<2, u32, CONVERT_MODE_DEFAULT>::fetch, conv<2, u32, CONVERT_MODE_DEFAULT>::write},				// FORMAT_D24_UNORM_S8_UINT_PACK32
+				{conv<2, u32, CONVERT_MODE_DEFAULT>::fetch, conv<2, u32, CONVERT_MODE_DEFAULT>::write},				// FORMAT_D32_SFLOAT_S8_UINT_PACK64
 
-				{conv<u8, tvec3, CONVERT_MODE_DEFAULT>::fetch, conv<u8, tvec3, CONVERT_MODE_DEFAULT>::write},				// FORMAT_RGB_DXT1_UNORM_BLOCK8
-				{conv<u8, tvec3, CONVERT_MODE_DEFAULT>::fetch, conv<u8, tvec3, CONVERT_MODE_DEFAULT>::write},				// FORMAT_RGB_DXT1_SRGB_BLOCK8
-				{conv<u8, tvec4, CONVERT_MODE_DEFAULT>::fetch, conv<u8, tvec4, CONVERT_MODE_DEFAULT>::write},				// FORMAT_RGBA_DXT1_UNORM_BLOCK8
-				{conv<u8, tvec4, CONVERT_MODE_DEFAULT>::fetch, conv<u8, tvec4, CONVERT_MODE_DEFAULT>::write},				// FORMAT_RGBA_DXT1_SRGB_BLOCK8
-				{conv<u8, tvec4, CONVERT_MODE_DEFAULT>::fetch, conv<u8, tvec4, CONVERT_MODE_DEFAULT>::write},				// FORMAT_RGBA_DXT3_UNORM_BLOCK16
-				{conv<u8, tvec4, CONVERT_MODE_DEFAULT>::fetch, conv<u8, tvec4, CONVERT_MODE_DEFAULT>::write},				// FORMAT_RGBA_DXT3_SRGB_BLOCK16
-				{conv<u8, tvec4, CONVERT_MODE_DEFAULT>::fetch, conv<u8, tvec4, CONVERT_MODE_DEFAULT>::write},				// FORMAT_RGBA_DXT5_UNORM_BLOCK16
-				{conv<u8, tvec4, CONVERT_MODE_DEFAULT>::fetch, conv<u8, tvec4, CONVERT_MODE_DEFAULT>::write},				// FORMAT_RGBA_DXT5_SRGB_BLOCK16
-				{conv<u8, tvec1, CONVERT_MODE_DEFAULT>::fetch, conv<u8, tvec1, CONVERT_MODE_DEFAULT>::write},				// FORMAT_R_ATI1N_UNORM_BLOCK8
-				{conv<u8, tvec1, CONVERT_MODE_DEFAULT>::fetch, conv<i8, tvec1, CONVERT_MODE_DEFAULT>::write},				// FORMAT_R_ATI1N_SNORM_BLOCK8
-				{conv<u8, tvec2, CONVERT_MODE_DEFAULT>::fetch, conv<u8, tvec2, CONVERT_MODE_DEFAULT>::write},				// FORMAT_RG_ATI2N_UNORM_BLOCK16
-				{conv<u8, tvec2, CONVERT_MODE_DEFAULT>::fetch, conv<i8, tvec2, CONVERT_MODE_DEFAULT>::write},				// FORMAT_RG_ATI2N_SNORM_BLOCK16
-				{conv<float, tvec3, CONVERT_MODE_DEFAULT>::fetch, conv<float, tvec3, CONVERT_MODE_DEFAULT>::write},			// FORMAT_RGB_BP_UFLOAT_BLOCK16
-				{conv<float, tvec3, CONVERT_MODE_DEFAULT>::fetch, conv<float, tvec3, CONVERT_MODE_DEFAULT>::write},			// FORMAT_RGB_BP_SFLOAT_BLOCK16
-				{conv<u8, tvec4, CONVERT_MODE_DEFAULT>::fetch, conv<u8, tvec4, CONVERT_MODE_DEFAULT>::write},				// FORMAT_RGBA_BP_UNORM_BLOCK16
-				{conv<u8, tvec4, CONVERT_MODE_DEFAULT>::fetch, conv<u8, tvec4, CONVERT_MODE_DEFAULT>::write},				// FORMAT_RGBA_BP_SRGB_BLOCK16
+				{conv<3, u8, CONVERT_MODE_DEFAULT>::fetch, conv<3, u8, CONVERT_MODE_DEFAULT>::write},				// FORMAT_RGB_DXT1_UNORM_BLOCK8
+				{conv<3, u8, CONVERT_MODE_DEFAULT>::fetch, conv<3, u8, CONVERT_MODE_DEFAULT>::write},				// FORMAT_RGB_DXT1_SRGB_BLOCK8
+				{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write},				// FORMAT_RGBA_DXT1_UNORM_BLOCK8
+				{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write},				// FORMAT_RGBA_DXT1_SRGB_BLOCK8
+				{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write},				// FORMAT_RGBA_DXT3_UNORM_BLOCK16
+				{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write},				// FORMAT_RGBA_DXT3_SRGB_BLOCK16
+				{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write},				// FORMAT_RGBA_DXT5_UNORM_BLOCK16
+				{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write},				// FORMAT_RGBA_DXT5_SRGB_BLOCK16
+				{conv<1, u8, CONVERT_MODE_DEFAULT>::fetch, conv<1, u8, CONVERT_MODE_DEFAULT>::write},				// FORMAT_R_ATI1N_UNORM_BLOCK8
+				{conv<1, u8, CONVERT_MODE_DEFAULT>::fetch, conv<1, i8, CONVERT_MODE_DEFAULT>::write},				// FORMAT_R_ATI1N_SNORM_BLOCK8
+				{conv<2, u8, CONVERT_MODE_DEFAULT>::fetch, conv<2, u8, CONVERT_MODE_DEFAULT>::write},				// FORMAT_RG_ATI2N_UNORM_BLOCK16
+				{conv<2, u8, CONVERT_MODE_DEFAULT>::fetch, conv<2, i8, CONVERT_MODE_DEFAULT>::write},				// FORMAT_RG_ATI2N_SNORM_BLOCK16
+				{conv<3, f32, CONVERT_MODE_DEFAULT>::fetch, conv<3, f32, CONVERT_MODE_DEFAULT>::write},				// FORMAT_RGB_BP_UFLOAT_BLOCK16
+				{conv<3, f32, CONVERT_MODE_DEFAULT>::fetch, conv<3, f32, CONVERT_MODE_DEFAULT>::write},				// FORMAT_RGB_BP_SFLOAT_BLOCK16
+				{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write},				// FORMAT_RGBA_BP_UNORM_BLOCK16
+				{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write},				// FORMAT_RGBA_BP_SRGB_BLOCK16
 
-				{conv<u8, tvec3, CONVERT_MODE_DEFAULT>::fetch, conv<u8, tvec3, CONVERT_MODE_DEFAULT>::write},				// FORMAT_RGB_ETC2_UNORM_BLOCK8
-				{conv<u8, tvec3, CONVERT_MODE_DEFAULT>::fetch, conv<u8, tvec3, CONVERT_MODE_DEFAULT>::write},				// FORMAT_RGB_ETC2_SRGB_BLOCK8
-				{conv<u8, tvec4, CONVERT_MODE_DEFAULT>::fetch, conv<u8, tvec4, CONVERT_MODE_DEFAULT>::write},				// FORMAT_RGBA_ETC2_A1_UNORM_BLOCK8
-				{conv<u8, tvec4, CONVERT_MODE_DEFAULT>::fetch, conv<u8, tvec4, CONVERT_MODE_DEFAULT>::write},				// FORMAT_RGBA_ETC2_A1_SRGB_BLOCK8
-				{conv<u8, tvec4, CONVERT_MODE_DEFAULT>::fetch, conv<u8, tvec4, CONVERT_MODE_DEFAULT>::write},				// FORMAT_RGBA_ETC2_UNORM_BLOCK16
-				{conv<u8, tvec4, CONVERT_MODE_DEFAULT>::fetch, conv<u8, tvec4, CONVERT_MODE_DEFAULT>::write},				// FORMAT_RGBA_ETC2_SRGB_BLOCK16
-				{conv<u8, tvec1, CONVERT_MODE_DEFAULT>::fetch, conv<u8, tvec1, CONVERT_MODE_DEFAULT>::write},				// FORMAT_R_EAC_UNORM_BLOCK8
-				{conv<u8, tvec1, CONVERT_MODE_DEFAULT>::fetch, conv<u8, tvec1, CONVERT_MODE_DEFAULT>::write},				// FORMAT_R_EAC_SNORM_BLOCK8
-				{conv<u8, tvec2, CONVERT_MODE_DEFAULT>::fetch, conv<u8, tvec2, CONVERT_MODE_DEFAULT>::write},				// FORMAT_RG_EAC_UNORM_BLOCK16
-				{conv<u8, tvec2, CONVERT_MODE_DEFAULT>::fetch, conv<u8, tvec2, CONVERT_MODE_DEFAULT>::write},				// FORMAT_RG_EAC_SNORM_BLOCK16
+				{conv<3, u8, CONVERT_MODE_DEFAULT>::fetch, conv<3, u8, CONVERT_MODE_DEFAULT>::write},				// FORMAT_RGB_ETC2_UNORM_BLOCK8
+				{conv<3, u8, CONVERT_MODE_DEFAULT>::fetch, conv<3, u8, CONVERT_MODE_DEFAULT>::write},				// FORMAT_RGB_ETC2_SRGB_BLOCK8
+				{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write},				// FORMAT_RGBA_ETC2_A1_UNORM_BLOCK8
+				{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write},				// FORMAT_RGBA_ETC2_A1_SRGB_BLOCK8
+				{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write},				// FORMAT_RGBA_ETC2_UNORM_BLOCK16
+				{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write},				// FORMAT_RGBA_ETC2_SRGB_BLOCK16
+				{conv<1, u8, CONVERT_MODE_DEFAULT>::fetch, conv<1, u8, CONVERT_MODE_DEFAULT>::write},				// FORMAT_R_EAC_UNORM_BLOCK8
+				{conv<1, u8, CONVERT_MODE_DEFAULT>::fetch, conv<1, u8, CONVERT_MODE_DEFAULT>::write},				// FORMAT_R_EAC_SNORM_BLOCK8
+				{conv<2, u8, CONVERT_MODE_DEFAULT>::fetch, conv<2, u8, CONVERT_MODE_DEFAULT>::write},				// FORMAT_RG_EAC_UNORM_BLOCK16
+				{conv<2, u8, CONVERT_MODE_DEFAULT>::fetch, conv<2, u8, CONVERT_MODE_DEFAULT>::write},				// FORMAT_RG_EAC_SNORM_BLOCK16
 
-				{conv<u8, tvec4, CONVERT_MODE_DEFAULT>::fetch, conv<u8, tvec4, CONVERT_MODE_DEFAULT>::write},				// FORMAT_ASTC_4x4_UNORM
-				{conv<u8, tvec4, CONVERT_MODE_DEFAULT>::fetch, conv<u8, tvec4, CONVERT_MODE_DEFAULT>::write},				// FORMAT_ASTC_4x4_SRGB
-				{conv<u8, tvec4, CONVERT_MODE_DEFAULT>::fetch, conv<u8, tvec4, CONVERT_MODE_DEFAULT>::write},				// FORMAT_ASTC_5x4_UNORM
-				{conv<u8, tvec4, CONVERT_MODE_DEFAULT>::fetch, conv<u8, tvec4, CONVERT_MODE_DEFAULT>::write},				// FORMAT_ASTC_5x4_SRGB
-				{conv<u8, tvec4, CONVERT_MODE_DEFAULT>::fetch, conv<u8, tvec4, CONVERT_MODE_DEFAULT>::write},				// FORMAT_ASTC_5x5_UNORM
-				{conv<u8, tvec4, CONVERT_MODE_DEFAULT>::fetch, conv<u8, tvec4, CONVERT_MODE_DEFAULT>::write},				// FORMAT_ASTC_5x5_SRGB
-				{conv<u8, tvec4, CONVERT_MODE_DEFAULT>::fetch, conv<u8, tvec4, CONVERT_MODE_DEFAULT>::write},				// FORMAT_ASTC_6x5_UNORM
-				{conv<u8, tvec4, CONVERT_MODE_DEFAULT>::fetch, conv<u8, tvec4, CONVERT_MODE_DEFAULT>::write},				// FORMAT_ASTC_6x5_SRGB
-				{conv<u8, tvec4, CONVERT_MODE_DEFAULT>::fetch, conv<u8, tvec4, CONVERT_MODE_DEFAULT>::write},				// FORMAT_ASTC_6x6_UNORM
-				{conv<u8, tvec4, CONVERT_MODE_DEFAULT>::fetch, conv<u8, tvec4, CONVERT_MODE_DEFAULT>::write},				// FORMAT_ASTC_6x6_SRGB
-				{conv<u8, tvec4, CONVERT_MODE_DEFAULT>::fetch, conv<u8, tvec4, CONVERT_MODE_DEFAULT>::write},				// FORMAT_ASTC_8x5_UNORM
-				{conv<u8, tvec4, CONVERT_MODE_DEFAULT>::fetch, conv<u8, tvec4, CONVERT_MODE_DEFAULT>::write},				// FORMAT_ASTC_8x5_SRGB
-				{conv<u8, tvec4, CONVERT_MODE_DEFAULT>::fetch, conv<u8, tvec4, CONVERT_MODE_DEFAULT>::write},				// FORMAT_ASTC_8x6_UNORM
-				{conv<u8, tvec4, CONVERT_MODE_DEFAULT>::fetch, conv<u8, tvec4, CONVERT_MODE_DEFAULT>::write},				// FORMAT_ASTC_8x6_SRGB
-				{conv<u8, tvec4, CONVERT_MODE_DEFAULT>::fetch, conv<u8, tvec4, CONVERT_MODE_DEFAULT>::write},				// FORMAT_ASTC_8x8_UNORM
-				{conv<u8, tvec4, CONVERT_MODE_DEFAULT>::fetch, conv<u8, tvec4, CONVERT_MODE_DEFAULT>::write},				// FORMAT_ASTC_8x8_SRGB
-				{conv<u8, tvec4, CONVERT_MODE_DEFAULT>::fetch, conv<u8, tvec4, CONVERT_MODE_DEFAULT>::write},				// FORMAT_ASTC_10x5_UNORM
-				{conv<u8, tvec4, CONVERT_MODE_DEFAULT>::fetch, conv<u8, tvec4, CONVERT_MODE_DEFAULT>::write},				// FORMAT_ASTC_10x5_SRGB
-				{conv<u8, tvec4, CONVERT_MODE_DEFAULT>::fetch, conv<u8, tvec4, CONVERT_MODE_DEFAULT>::write},				// FORMAT_ASTC_10x6_UNORM
-				{conv<u8, tvec4, CONVERT_MODE_DEFAULT>::fetch, conv<u8, tvec4, CONVERT_MODE_DEFAULT>::write},				// FORMAT_ASTC_10x6_SRGB
-				{conv<u8, tvec4, CONVERT_MODE_DEFAULT>::fetch, conv<u8, tvec4, CONVERT_MODE_DEFAULT>::write},				// FORMAT_ASTC_10x8_UNORM
-				{conv<u8, tvec4, CONVERT_MODE_DEFAULT>::fetch, conv<u8, tvec4, CONVERT_MODE_DEFAULT>::write},				// FORMAT_ASTC_10x8_SRGB
-				{conv<u8, tvec4, CONVERT_MODE_DEFAULT>::fetch, conv<u8, tvec4, CONVERT_MODE_DEFAULT>::write},				// FORMAT_ASTC_10x10_UNORM
-				{conv<u8, tvec4, CONVERT_MODE_DEFAULT>::fetch, conv<u8, tvec4, CONVERT_MODE_DEFAULT>::write},				// FORMAT_ASTC_10x10_SRGB
-				{conv<u8, tvec4, CONVERT_MODE_DEFAULT>::fetch, conv<u8, tvec4, CONVERT_MODE_DEFAULT>::write},				// FORMAT_ASTC_12x10_UNORM
-				{conv<u8, tvec4, CONVERT_MODE_DEFAULT>::fetch, conv<u8, tvec4, CONVERT_MODE_DEFAULT>::write},				// FORMAT_ASTC_12x10_SRGB
-				{conv<u8, tvec4, CONVERT_MODE_DEFAULT>::fetch, conv<u8, tvec4, CONVERT_MODE_DEFAULT>::write},				// FORMAT_ASTC_12x12_UNORM
-				{conv<u8, tvec4, CONVERT_MODE_DEFAULT>::fetch, conv<u8, tvec4, CONVERT_MODE_DEFAULT>::write},				// FORMAT_ASTC_12x12_SRGB
+				{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write},				// FORMAT_ASTC_4x4_UNORM
+				{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write},				// FORMAT_ASTC_4x4_SRGB
+				{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write},				// FORMAT_ASTC_5x4_UNORM
+				{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write},				// FORMAT_ASTC_5x4_SRGB
+				{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write},				// FORMAT_ASTC_5x5_UNORM
+				{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write},				// FORMAT_ASTC_5x5_SRGB
+				{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write},				// FORMAT_ASTC_6x5_UNORM
+				{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write},				// FORMAT_ASTC_6x5_SRGB
+				{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write},				// FORMAT_ASTC_6x6_UNORM
+				{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write},				// FORMAT_ASTC_6x6_SRGB
+				{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write},				// FORMAT_ASTC_8x5_UNORM
+				{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write},				// FORMAT_ASTC_8x5_SRGB
+				{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write},				// FORMAT_ASTC_8x6_UNORM
+				{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write},				// FORMAT_ASTC_8x6_SRGB
+				{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write},				// FORMAT_ASTC_8x8_UNORM
+				{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write},				// FORMAT_ASTC_8x8_SRGB
+				{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write},				// FORMAT_ASTC_10x5_UNORM
+				{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write},				// FORMAT_ASTC_10x5_SRGB
+				{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write},				// FORMAT_ASTC_10x6_UNORM
+				{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write},				// FORMAT_ASTC_10x6_SRGB
+				{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write},				// FORMAT_ASTC_10x8_UNORM
+				{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write},				// FORMAT_ASTC_10x8_SRGB
+				{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write},				// FORMAT_ASTC_10x10_UNORM
+				{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write},				// FORMAT_ASTC_10x10_SRGB
+				{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write},				// FORMAT_ASTC_12x10_UNORM
+				{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write},				// FORMAT_ASTC_12x10_SRGB
+				{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write},				// FORMAT_ASTC_12x12_UNORM
+				{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write},				// FORMAT_ASTC_12x12_SRGB
 
-				{conv<u8, tvec3, CONVERT_MODE_DEFAULT>::fetch, conv<u8, tvec3, CONVERT_MODE_DEFAULT>::write},				// FORMAT_RGB_PVRTC1_8X8_UNORM_BLOCK32
-				{conv<u8, tvec3, CONVERT_MODE_DEFAULT>::fetch, conv<u8, tvec3, CONVERT_MODE_DEFAULT>::write},				// FORMAT_RGB_PVRTC1_8X8_SRGB_BLOCK32
-				{conv<u8, tvec3, CONVERT_MODE_DEFAULT>::fetch, conv<u8, tvec3, CONVERT_MODE_DEFAULT>::write},				// FORMAT_RGB_PVRTC1_16X8_UNORM_BLOCK32
-				{conv<u8, tvec3, CONVERT_MODE_DEFAULT>::fetch, conv<u8, tvec3, CONVERT_MODE_DEFAULT>::write},				// FORMAT_RGB_PVRTC1_16X8_SRGB_BLOCK32
-				{conv<u8, tvec4, CONVERT_MODE_DEFAULT>::fetch, conv<u8, tvec4, CONVERT_MODE_DEFAULT>::write},				// FORMAT_RGBA_PVRTC1_8X8_UNORM_BLOCK32
-				{conv<u8, tvec4, CONVERT_MODE_DEFAULT>::fetch, conv<u8, tvec4, CONVERT_MODE_DEFAULT>::write},				// FORMAT_RGBA_PVRTC1_8X8_SRGB_BLOCK32
-				{conv<u8, tvec4, CONVERT_MODE_DEFAULT>::fetch, conv<u8, tvec4, CONVERT_MODE_DEFAULT>::write},				// FORMAT_RGBA_PVRTC1_16X8_UNORM_BLOCK32
-				{conv<u8, tvec4, CONVERT_MODE_DEFAULT>::fetch, conv<u8, tvec4, CONVERT_MODE_DEFAULT>::write},				// FORMAT_RGBA_PVRTC1_16X8_SRGB_BLOCK32
-				{conv<u8, tvec4, CONVERT_MODE_DEFAULT>::fetch, conv<u8, tvec4, CONVERT_MODE_DEFAULT>::write},				// FORMAT_RGBA_PVRTC2_4X4_UNORM_BLOCK8
-				{conv<u8, tvec4, CONVERT_MODE_DEFAULT>::fetch, conv<u8, tvec4, CONVERT_MODE_DEFAULT>::write},				// FORMAT_RGBA_PVRTC2_4X4_SRGB_BLOCK8
-				{conv<u8, tvec4, CONVERT_MODE_DEFAULT>::fetch, conv<u8, tvec4, CONVERT_MODE_DEFAULT>::write},				// FORMAT_RGBA_PVRTC2_8X4_UNORM_BLOCK8
-				{conv<u8, tvec4, CONVERT_MODE_DEFAULT>::fetch, conv<u8, tvec4, CONVERT_MODE_DEFAULT>::write},				// FORMAT_RGBA_PVRTC2_8X4_SRGB_BLOCK8
+				{conv<3, u8, CONVERT_MODE_DEFAULT>::fetch, conv<3, u8, CONVERT_MODE_DEFAULT>::write},				// FORMAT_RGB_PVRTC1_8X8_UNORM_BLOCK32
+				{conv<3, u8, CONVERT_MODE_DEFAULT>::fetch, conv<3, u8, CONVERT_MODE_DEFAULT>::write},				// FORMAT_RGB_PVRTC1_8X8_SRGB_BLOCK32
+				{conv<3, u8, CONVERT_MODE_DEFAULT>::fetch, conv<3, u8, CONVERT_MODE_DEFAULT>::write},				// FORMAT_RGB_PVRTC1_16X8_UNORM_BLOCK32
+				{conv<3, u8, CONVERT_MODE_DEFAULT>::fetch, conv<3, u8, CONVERT_MODE_DEFAULT>::write},				// FORMAT_RGB_PVRTC1_16X8_SRGB_BLOCK32
+				{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write},				// FORMAT_RGBA_PVRTC1_8X8_UNORM_BLOCK32
+				{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write},				// FORMAT_RGBA_PVRTC1_8X8_SRGB_BLOCK32
+				{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write},				// FORMAT_RGBA_PVRTC1_16X8_UNORM_BLOCK32
+				{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write},				// FORMAT_RGBA_PVRTC1_16X8_SRGB_BLOCK32
+				{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write},				// FORMAT_RGBA_PVRTC2_4X4_UNORM_BLOCK8
+				{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write},				// FORMAT_RGBA_PVRTC2_4X4_SRGB_BLOCK8
+				{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write},				// FORMAT_RGBA_PVRTC2_8X4_UNORM_BLOCK8
+				{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write},				// FORMAT_RGBA_PVRTC2_8X4_SRGB_BLOCK8
 
-				{conv<u8, tvec3, CONVERT_MODE_DEFAULT>::fetch, conv<u8, tvec3, CONVERT_MODE_DEFAULT>::write},				// FORMAT_RGB_ETC_UNORM_BLOCK8
-				{conv<u8, tvec3, CONVERT_MODE_DEFAULT>::fetch, conv<u8, tvec3, CONVERT_MODE_DEFAULT>::write},				// FORMAT_RGB_ATC_UNORM_BLOCK8
-				{conv<u8, tvec4, CONVERT_MODE_DEFAULT>::fetch, conv<u8, tvec4, CONVERT_MODE_DEFAULT>::write},				// FORMAT_RGBA_ATCA_UNORM_BLOCK16
-				{conv<u8, tvec4, CONVERT_MODE_DEFAULT>::fetch, conv<u8, tvec4, CONVERT_MODE_DEFAULT>::write},				// FORMAT_RGBA_ATCI_UNORM_BLOCK16
+				{conv<3, u8, CONVERT_MODE_DEFAULT>::fetch, conv<3, u8, CONVERT_MODE_DEFAULT>::write},				// FORMAT_RGB_ETC_UNORM_BLOCK8
+				{conv<3, u8, CONVERT_MODE_DEFAULT>::fetch, conv<3, u8, CONVERT_MODE_DEFAULT>::write},				// FORMAT_RGB_ATC_UNORM_BLOCK8
+				{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write},				// FORMAT_RGBA_ATCA_UNORM_BLOCK16
+				{conv<4, u8, CONVERT_MODE_DEFAULT>::fetch, conv<4, u8, CONVERT_MODE_DEFAULT>::write},				// FORMAT_RGBA_ATCI_UNORM_BLOCK16
 
-				{conv<u8, tvec1, CONVERT_MODE_NORM>::fetch, conv<u8, tvec1, CONVERT_MODE_NORM>::write},						// FORMAT_L8_UNORM_PACK8
-				{conv<u8, tvec1, CONVERT_MODE_NORM>::fetch, conv<u8, tvec1, CONVERT_MODE_NORM>::write},						// FORMAT_A8_UNORM_PACK8
-				{conv<u8, tvec2, CONVERT_MODE_NORM>::fetch, conv<u8, tvec2, CONVERT_MODE_NORM>::write},						// FORMAT_LA8_UNORM_PACK8
-				{conv<u16, tvec1, CONVERT_MODE_NORM>::fetch, conv<u16, tvec1, CONVERT_MODE_NORM>::write},					// FORMAT_L16_UNORM_PACK16
-				{conv<u16, tvec1, CONVERT_MODE_NORM>::fetch, conv<u16, tvec1, CONVERT_MODE_NORM>::write},					// FORMAT_A16_UNORM_PACK16
-				{conv<u16, tvec2, CONVERT_MODE_NORM>::fetch, conv<u16, tvec2, CONVERT_MODE_NORM>::write},					// FORMAT_LA16_UNORM_PACK16
+				{conv<1, u8, CONVERT_MODE_NORM>::fetch, conv<1, u8, CONVERT_MODE_NORM>::write},						// FORMAT_L8_UNORM_PACK8
+				{conv<1, u8, CONVERT_MODE_NORM>::fetch, conv<1, u8, CONVERT_MODE_NORM>::write},						// FORMAT_A8_UNORM_PACK8
+				{conv<2, u8, CONVERT_MODE_NORM>::fetch, conv<2, u8, CONVERT_MODE_NORM>::write},						// FORMAT_LA8_UNORM_PACK8
+				{conv<1, u16, CONVERT_MODE_NORM>::fetch, conv<1, u16, CONVERT_MODE_NORM>::write},					// FORMAT_L16_UNORM_PACK16
+				{conv<1, u16, CONVERT_MODE_NORM>::fetch, conv<1, u16, CONVERT_MODE_NORM>::write},					// FORMAT_A16_UNORM_PACK16
+				{conv<2, u16, CONVERT_MODE_NORM>::fetch, conv<2, u16, CONVERT_MODE_NORM>::write},					// FORMAT_LA16_UNORM_PACK16
 
-				{conv<u8, tvec4, CONVERT_MODE_NORM>::fetch, conv<u8, tvec4, CONVERT_MODE_NORM>::write},						// FORMAT_BGRX8_UNORM
-				{conv<u8, tvec4, CONVERT_MODE_SRGB>::fetch, conv<u8, tvec4, CONVERT_MODE_SRGB>::write},						// FORMAT_BGRX8_SRGB
+				{conv<4, u8, CONVERT_MODE_NORM>::fetch, conv<4, u8, CONVERT_MODE_NORM>::write},						// FORMAT_BGRX8_UNORM
+				{conv<4, u8, CONVERT_MODE_SRGB>::fetch, conv<4, u8, CONVERT_MODE_SRGB>::write},						// FORMAT_BGRX8_SRGB
 
-				{conv<u8, tvec3, CONVERT_MODE_332UNORM>::fetch, conv<u8, tvec3, CONVERT_MODE_332UNORM>::write}				// FORMAT_RG3B2_UNORM
+				{conv<3, u8, CONVERT_MODE_332UNORM>::fetch, conv<3, u8, CONVERT_MODE_332UNORM>::write}				// FORMAT_RG3B2_UNORM
 			};
 			static_assert(sizeof(Table) / sizeof(Table[0]) == FORMAT_COUNT, "Texel functions need to be updated");
 
diff --git a/test/external/gli/core/coord.hpp b/test/external/gli/core/coord.hpp
index aede0f20..e78081b3 100644
--- a/test/external/gli/core/coord.hpp
+++ b/test/external/gli/core/coord.hpp
@@ -5,8 +5,8 @@
 namespace gli{
 namespace detail
 {
-	template <typename T, precision P, template <typename, precision> class vecType>
-	inline vecType<bool, P> in_interval(vecType<T, P> const& Value, vecType<T, P> const& Min, vecType<T, P> const& Max)
+	template <length_t L, typename T, precision P>
+	inline vec<L, bool, P> in_interval(vec<L, T, P> const& Value, vec<L, T, P> const& Min, vec<L, T, P> const& Max)
 	{
 		return greaterThanEqual(Value, Min) && lessThanEqual(Value, Max);
 	}
diff --git a/test/external/gli/core/levels.inl b/test/external/gli/core/levels.inl
index 50043b4c..a2f49a6d 100644
--- a/test/external/gli/core/levels.inl
+++ b/test/external/gli/core/levels.inl
@@ -1,10 +1,11 @@
 #include <glm/gtc/integer.hpp>
+#define GLM_ENABLE_EXPERIMENTAL
 #include <glm/gtx/component_wise.hpp>
 
 namespace gli
 {
-	template <typename T, precision P, template <typename, precision> class vecType>
-	inline T levels(vecType<T, P> const& Extent)
+	template <length_t L, typename T, precision P, template <length_t, typename, precision> class vecType>
+	inline T levels(vecType<L, T, P> const& Extent)
 	{
 		return glm::log2(compMax(Extent)) + static_cast<T>(1);
 	}
diff --git a/test/external/gli/core/reduce.inl b/test/external/gli/core/reduce.inl
index 0830aa6b..fd127212 100644
--- a/test/external/gli/core/reduce.inl
+++ b/test/external/gli/core/reduce.inl
@@ -11,7 +11,7 @@ namespace gli
 	template <typename val_type>
 	struct binary_func
 	{
-		typedef tvec4<val_type>(*type)(tvec4<val_type> const& A, tvec4<val_type> const& B);
+		typedef vec<4, val_type>(*type)(vec<4, val_type> const& A, vec<4, val_type> const& B);
 	};
 
 namespace detail
@@ -28,13 +28,13 @@ namespace detail
 		typedef texture1d::size_type size_type;
 		typedef texture1d::extent_type extent_type;
 
-		static tvec4<val_type> call(texture1d const& A, texture1d const& B, binary_func<val_type> TexelFunc, binary_func<val_type> ReduceFunc)
+		static vec<4, val_type> call(texture1d const& A, texture1d const& B, binary_func<val_type> TexelFunc, binary_func<val_type> ReduceFunc)
 		{
 			GLI_ASSERT(are_compatible(A, B));
 
 			sampler1d<val_type> const SamplerA(A, gli::WRAP_CLAMP_TO_EDGE), SamplerB(B, gli::WRAP_CLAMP_TO_EDGE);
 			extent_type TexelIndex(0);
-			tvec4<val_type> Result(TexelFunc(SamplerA.template fetch(TexelIndex, 0), SamplerB.template fetch(TexelIndex, 0)));
+			vec<4, val_type> Result(TexelFunc(SamplerA.template fetch(TexelIndex, 0), SamplerB.template fetch(TexelIndex, 0)));
 
 			for(size_type LevelIndex = 0, LevelCount = A.levels(); LevelIndex < LevelCount; ++LevelIndex)
 			{
@@ -58,13 +58,13 @@ namespace detail
 		typedef texture1d_array::size_type size_type;
 		typedef texture1d_array::extent_type extent_type;
 
-		static tvec4<val_type> call(texture1d_array const& A, texture1d_array const& B, binary_func<val_type> TexelFunc, binary_func<val_type> ReduceFunc)
+		static vec<4, val_type> call(texture1d_array const& A, texture1d_array const& B, binary_func<val_type> TexelFunc, binary_func<val_type> ReduceFunc)
 		{
 			GLI_ASSERT(are_compatible(A, B));
 
 			sampler1d_array<val_type> const SamplerA(A, gli::WRAP_CLAMP_TO_EDGE), SamplerB(B, gli::WRAP_CLAMP_TO_EDGE);
 			extent_type TexelIndex(0);
-			tvec4<val_type> Result(TexelFunc(SamplerA.template fetch(TexelIndex, 0, 0), SamplerB.template fetch(TexelIndex, 0, 0)));
+			vec<4, val_type> Result(TexelFunc(SamplerA.template fetch(TexelIndex, 0, 0), SamplerB.template fetch(TexelIndex, 0, 0)));
 
 			for(size_type LayerIndex = 0, LayerCount = A.layers(); LayerIndex < LayerCount; ++LayerIndex)
 			for(size_type LevelIndex = 0, LevelCount = A.levels(); LevelIndex < LevelCount; ++LevelIndex)
@@ -89,13 +89,13 @@ namespace detail
 		typedef texture2d::size_type size_type;
 		typedef texture2d::extent_type extent_type;
 
-		static tvec4<val_type> call(texture2d const& A, texture2d const& B, binary_func<val_type> TexelFunc, binary_func<val_type> ReduceFunc)
+		static vec<4, val_type> call(texture2d const& A, texture2d const& B, binary_func<val_type> TexelFunc, binary_func<val_type> ReduceFunc)
 		{
 			GLI_ASSERT(are_compatible(A, B));
 
 			sampler2d<val_type> const SamplerA(A, gli::WRAP_CLAMP_TO_EDGE), SamplerB(B, gli::WRAP_CLAMP_TO_EDGE);
 			extent_type TexelIndex(0);
-			tvec4<val_type> Result(TexelFunc(SamplerA.template fetch(TexelIndex, 0), SamplerB.template fetch(TexelIndex, 0)));
+			vec<4, val_type> Result(TexelFunc(SamplerA.template fetch(TexelIndex, 0), SamplerB.template fetch(TexelIndex, 0)));
 
 			for(size_type LevelIndex = 0, LevelCount = A.levels(); LevelIndex < LevelCount; ++LevelIndex)
 			{
@@ -120,13 +120,13 @@ namespace detail
 		typedef texture2d_array::size_type size_type;
 		typedef texture2d_array::extent_type extent_type;
 
-		static tvec4<val_type> call(texture2d_array const& A, texture2d_array const& B, binary_func<val_type> TexelFunc, binary_func<val_type> ReduceFunc)
+		static vec<4, val_type> call(texture2d_array const& A, texture2d_array const& B, binary_func<val_type> TexelFunc, binary_func<val_type> ReduceFunc)
 		{
 			GLI_ASSERT(are_compatible(A, B));
 
 			sampler2d_array<val_type> const SamplerA(A, gli::WRAP_CLAMP_TO_EDGE), SamplerB(B, gli::WRAP_CLAMP_TO_EDGE);
 			extent_type TexelIndex(0);
-			tvec4<val_type> Result(TexelFunc(SamplerA.template fetch(TexelIndex, 0, 0), SamplerB.template fetch(TexelIndex, 0, 0)));
+			vec<4, val_type> Result(TexelFunc(SamplerA.template fetch(TexelIndex, 0, 0), SamplerB.template fetch(TexelIndex, 0, 0)));
 
 			for(size_type LayerIndex = 0, LayerCount = A.layers(); LayerIndex < LayerCount; ++LayerIndex)
 			for(size_type LevelIndex = 0, LevelCount = A.levels(); LevelIndex < LevelCount; ++LevelIndex)
@@ -152,13 +152,13 @@ namespace detail
 		typedef texture3d::size_type size_type;
 		typedef texture3d::extent_type extent_type;
 
-		static tvec4<val_type> call(texture3d const& A, texture3d const& B, binary_func<val_type> TexelFunc, binary_func<val_type> ReduceFunc)
+		static vec<4, val_type> call(texture3d const& A, texture3d const& B, binary_func<val_type> TexelFunc, binary_func<val_type> ReduceFunc)
 		{
 			GLI_ASSERT(are_compatible(A, B));
 
 			sampler3d<val_type> const SamplerA(A, gli::WRAP_CLAMP_TO_EDGE), SamplerB(B, gli::WRAP_CLAMP_TO_EDGE);
 			extent_type TexelIndex(0);
-			tvec4<val_type> Result(TexelFunc(SamplerA.template fetch(TexelIndex, 0), SamplerB.template fetch(TexelIndex, 0)));
+			vec<4, val_type> Result(TexelFunc(SamplerA.template fetch(TexelIndex, 0), SamplerB.template fetch(TexelIndex, 0)));
 
 			for(size_type LevelIndex = 0, LevelCount = A.levels(); LevelIndex < LevelCount; ++LevelIndex)
 			{
@@ -184,13 +184,13 @@ namespace detail
 		typedef texture_cube::size_type size_type;
 		typedef texture_cube::extent_type extent_type;
 
-		static tvec4<val_type> call(texture_cube const& A, texture_cube const& B, binary_func<val_type> TexelFunc, binary_func<val_type> ReduceFunc)
+		static vec<4, val_type> call(texture_cube const& A, texture_cube const& B, binary_func<val_type> TexelFunc, binary_func<val_type> ReduceFunc)
 		{
 			GLI_ASSERT(are_compatible(A, B));
 
 			sampler_cube<val_type> const SamplerA(A, gli::WRAP_CLAMP_TO_EDGE), SamplerB(B, gli::WRAP_CLAMP_TO_EDGE);
 			extent_type TexelIndex(0);
-			tvec4<val_type> Result(TexelFunc(SamplerA.template fetch(TexelIndex, 0, 0), SamplerB.template fetch(TexelIndex, 0, 0)));
+			vec<4, val_type> Result(TexelFunc(SamplerA.template fetch(TexelIndex, 0, 0), SamplerB.template fetch(TexelIndex, 0, 0)));
 
 			for(size_type FaceIndex = 0, FaceCount = A.faces(); FaceIndex < FaceCount; ++FaceIndex)
 			for(size_type LevelIndex = 0, LevelCount = A.levels(); LevelIndex < LevelCount; ++LevelIndex)
@@ -216,13 +216,13 @@ namespace detail
 		typedef texture_cube_array::size_type size_type;
 		typedef texture_cube_array::extent_type extent_type;
 
-		static tvec4<val_type> call(texture_cube_array const& A, texture_cube_array const& B, binary_func<val_type> TexelFunc, binary_func<val_type> ReduceFunc)
+		static vec<4, val_type> call(texture_cube_array const& A, texture_cube_array const& B, binary_func<val_type> TexelFunc, binary_func<val_type> ReduceFunc)
 		{
 			GLI_ASSERT(are_compatible(A, B));
 
 			sampler_cube_array<val_type> const SamplerA(A, gli::WRAP_CLAMP_TO_EDGE), SamplerB(B, gli::WRAP_CLAMP_TO_EDGE);
 			extent_type TexelIndex(0);
-			tvec4<val_type> Result(TexelFunc(SamplerA.template fetch(TexelIndex, 0, 0, 0), SamplerB.template fetch(TexelIndex, 0, 0, 0)));
+			vec<4, val_type> Result(TexelFunc(SamplerA.template fetch(TexelIndex, 0, 0, 0), SamplerB.template fetch(TexelIndex, 0, 0, 0)));
 
 			for(size_type LayerIndex = 0, LayerCount = A.layers(); LayerIndex < LayerCount; ++LayerIndex)
 			for(size_type FaceIndex = 0, FaceCount = A.faces(); FaceIndex < FaceCount; ++FaceIndex)
diff --git a/test/external/gli/core/sampler.inl b/test/external/gli/core/sampler.inl
index bd73cc07..e0b64631 100644
--- a/test/external/gli/core/sampler.inl
+++ b/test/external/gli/core/sampler.inl
@@ -1,3 +1,4 @@
+#define GLM_ENABLE_EXPERIMENTAL
 #include <glm/gtx/wrap.hpp>
 
 namespace gli{
diff --git a/test/external/gli/core/workaround.hpp b/test/external/gli/core/workaround.hpp
index be0abb11..a8ba1e0e 100644
--- a/test/external/gli/core/workaround.hpp
+++ b/test/external/gli/core/workaround.hpp
@@ -202,19 +202,19 @@ namespace detail
 	template <precision P>
 	struct compute_half<P, tvec4>
 	{
-		GLM_FUNC_QUALIFIER static tvec4<uint16, P> pack(tvec4<float, P> const & v)
+		GLM_FUNC_QUALIFIER static vec<4, uint16, P> pack(vec<4, float, P> const & v)
 		{
-			tvec4<int16, P> const Unpacked(glm::detail::toFloat16(v.x), glm::detail::toFloat16(v.y), glm::detail::toFloat16(v.z), glm::detail::toFloat16(v.w));
-			return tvec4<uint16, P>(
+			vec<4, int16, P> const Unpacked(glm::detail::toFloat16(v.x), glm::detail::toFloat16(v.y), glm::detail::toFloat16(v.z), glm::detail::toFloat16(v.w));
+			return vec<4, uint16, P>(
 				reinterpret_cast<uint16 const &>(Unpacked.x),
 				reinterpret_cast<uint16 const &>(Unpacked.y),
 				reinterpret_cast<uint16 const &>(Unpacked.z),
 				reinterpret_cast<uint16 const &>(Unpacked.w));
 		}
 
-		GLM_FUNC_QUALIFIER static tvec4<float, P> unpack(tvec4<uint16, P> const & v)
+		GLM_FUNC_QUALIFIER static vec<4, float, P> unpack(vec<4, uint16, P> const & v)
 		{
-			return tvec4<float, P>(
+			return vec<4, float, P>(
 				glm::detail::toFloat32(reinterpret_cast<int16 const &>(v.x)),
 				glm::detail::toFloat32(reinterpret_cast<int16 const &>(v.y)),
 				glm::detail::toFloat32(reinterpret_cast<int16 const &>(v.z)),
diff --git a/test/external/gli/format.hpp b/test/external/gli/format.hpp
index ef044492..d6854d78 100644
--- a/test/external/gli/format.hpp
+++ b/test/external/gli/format.hpp
@@ -285,7 +285,7 @@ namespace gli
 		return Format >= FORMAT_FIRST && Format <= FORMAT_LAST;
 	}
 
-	typedef glm::tvec4<swizzle> swizzles;
+	typedef glm::vec<4, swizzle> swizzles;
 
 	/// Evaluate whether a format is compressed
 	bool is_compressed(format Format);
diff --git a/test/external/gli/gl.hpp b/test/external/gli/gl.hpp
index 82584e55..5be5f44b 100644
--- a/test/external/gli/gl.hpp
+++ b/test/external/gli/gl.hpp
@@ -328,7 +328,7 @@ namespace gli
 			PROFILE_KTX
 		};
 
-		typedef glm::tvec4<int> swizzles;
+		typedef glm::vec<4, int> swizzles;
 
 		struct format
 		{
diff --git a/test/external/gli/gli.hpp b/test/external/gli/gli.hpp
index b4903122..0639a94b 100644
--- a/test/external/gli/gli.hpp
+++ b/test/external/gli/gli.hpp
@@ -59,6 +59,7 @@ namespace gli
 #include "sampler_cube_array.hpp"
 
 #include "duplicate.hpp"
+#include "convert.hpp"
 #include "view.hpp"
 #include "comparison.hpp"
 
diff --git a/test/external/gli/sampler1d.hpp b/test/external/gli/sampler1d.hpp
index 98669c77..24656180 100644
--- a/test/external/gli/sampler1d.hpp
+++ b/test/external/gli/sampler1d.hpp
@@ -24,8 +24,8 @@ namespace gli
 		typedef typename texture_type::size_type size_type;
 		typedef typename texture_type::extent_type extent_type;
 		typedef interpolate_type level_type;
-		typedef tvec1<interpolate_type, P> normalized_type;
-		typedef tvec4<T, P> texel_type;
+		typedef vec<1, interpolate_type, P> normalized_type;
+		typedef vec<4, T, P> texel_type;
 
 		sampler1d(texture_type const& Texture, wrap Wrap, filter Mip = FILTER_NEAREST, filter Min = FILTER_NEAREST, texel_type const& BorderColor = texel_type(0, 0, 0, 1));
 
diff --git a/test/external/gli/sampler1d_array.hpp b/test/external/gli/sampler1d_array.hpp
index ca0bfc33..d07b342a 100644
--- a/test/external/gli/sampler1d_array.hpp
+++ b/test/external/gli/sampler1d_array.hpp
@@ -24,8 +24,8 @@ namespace gli
 		typedef typename texture_type::size_type size_type;
 		typedef typename texture_type::extent_type extent_type;
 		typedef interpolate_type level_type;
-		typedef tvec1<interpolate_type, P> normalized_type;
-		typedef tvec4<T, P> texel_type;
+		typedef vec<1, interpolate_type, P> normalized_type;
+		typedef vec<4, T, P> texel_type;
 
 		sampler1d_array(texture_type const& Texture, wrap Wrap, filter Mip = FILTER_NEAREST, filter Min = FILTER_NEAREST, texel_type const& BorderColor = texel_type(0, 0, 0, 1));
 
diff --git a/test/external/gli/sampler2d.hpp b/test/external/gli/sampler2d.hpp
index 77eacd00..8eaf11a8 100644
--- a/test/external/gli/sampler2d.hpp
+++ b/test/external/gli/sampler2d.hpp
@@ -24,8 +24,8 @@ namespace gli
 		typedef typename texture_type::size_type size_type;
 		typedef typename texture_type::extent_type extent_type;
 		typedef interpolate_type level_type;
-		typedef tvec2<interpolate_type, P> normalized_type;
-		typedef tvec4<T, P> texel_type;
+		typedef vec<2, interpolate_type, P> normalized_type;
+		typedef vec<4, T, P> texel_type;
 
 		sampler2d(texture_type const& Texture, wrap Wrap, filter Mip = FILTER_NEAREST, filter Min = FILTER_NEAREST, texel_type const& BorderColor = texel_type(0, 0, 0, 1));
 
diff --git a/test/external/gli/sampler2d_array.hpp b/test/external/gli/sampler2d_array.hpp
index c1b83b43..24ffe960 100644
--- a/test/external/gli/sampler2d_array.hpp
+++ b/test/external/gli/sampler2d_array.hpp
@@ -24,8 +24,8 @@ namespace gli
 		typedef typename texture_type::size_type size_type;
 		typedef typename texture_type::extent_type extent_type;
 		typedef interpolate_type level_type;
-		typedef tvec2<interpolate_type, P> normalized_type;
-		typedef tvec4<T, P> texel_type;
+		typedef vec<2, interpolate_type, P> normalized_type;
+		typedef vec<4, T, P> texel_type;
 
 		sampler2d_array(texture_type const& Texture, wrap Wrap, filter Mip = FILTER_NEAREST, filter Min = FILTER_NEAREST, texel_type const& BorderColor = texel_type(0, 0, 0, 1));
 
diff --git a/test/external/gli/sampler3d.hpp b/test/external/gli/sampler3d.hpp
index bb5c5439..556df7c5 100644
--- a/test/external/gli/sampler3d.hpp
+++ b/test/external/gli/sampler3d.hpp
@@ -24,8 +24,8 @@ namespace gli
 		typedef typename texture_type::size_type size_type;
 		typedef typename texture_type::extent_type extent_type;
 		typedef interpolate_type level_type;
-		typedef tvec3<interpolate_type, P> normalized_type;
-		typedef tvec4<T, P> texel_type;
+		typedef vec<3, interpolate_type, P> normalized_type;
+		typedef vec<4, T, P> texel_type;
 
 		sampler3d(texture_type const& Texture, wrap Wrap, filter Mip = FILTER_NEAREST, filter Min = FILTER_NEAREST, texel_type const& BorderColor = texel_type(0, 0, 0, 1));
 
diff --git a/test/external/gli/sampler_cube.hpp b/test/external/gli/sampler_cube.hpp
index 128b4d8d..cdfcb84b 100644
--- a/test/external/gli/sampler_cube.hpp
+++ b/test/external/gli/sampler_cube.hpp
@@ -24,8 +24,8 @@ namespace gli
 		typedef typename texture_type::size_type size_type;
 		typedef typename texture_type::extent_type extent_type;
 		typedef interpolate_type level_type;
-		typedef tvec2<interpolate_type, P> normalized_type;
-		typedef tvec4<T, P> texel_type;
+		typedef vec<2, interpolate_type, P> normalized_type;
+		typedef vec<4, T, P> texel_type;
 
 		sampler_cube(texture_type const& Texture, wrap Wrap, filter Mip = FILTER_NEAREST, filter Min = FILTER_NEAREST, texel_type const& BorderColor = texel_type(0, 0, 0, 1));
 
diff --git a/test/external/gli/sampler_cube_array.hpp b/test/external/gli/sampler_cube_array.hpp
index 57885d8b..6eccf4a9 100644
--- a/test/external/gli/sampler_cube_array.hpp
+++ b/test/external/gli/sampler_cube_array.hpp
@@ -24,8 +24,8 @@ namespace gli
 		typedef typename texture_type::size_type size_type;
 		typedef typename texture_type::extent_type extent_type;
 		typedef interpolate_type level_type;
-		typedef tvec2<interpolate_type, P> normalized_type;
-		typedef tvec4<T, P> texel_type;
+		typedef vec<2, interpolate_type, P> normalized_type;
+		typedef vec<4, T, P> texel_type;
 
 		sampler_cube_array(texture_type const& Texture, wrap Wrap, filter Mip = FILTER_NEAREST, filter Min = FILTER_NEAREST, texel_type const& BorderColor = texel_type(0, 0, 0, 1));
 
diff --git a/test/external/gli/type.hpp b/test/external/gli/type.hpp
index 2afc7a7e..b299b3dd 100644
--- a/test/external/gli/type.hpp
+++ b/test/external/gli/type.hpp
@@ -10,7 +10,7 @@
 #define GLM_FORCE_EXPLICIT_CTOR
 #include <glm/glm.hpp>
 #include <glm/gtc/vec1.hpp>
-#include <glm/gtx/std_based_type.hpp>
+#define GLM_ENABLE_EXPERIMENTAL
 
 #if GLM_COMPILER & GLM_COMPILER_VC
 #	define GLI_FORCE_INLINE __forceinline
@@ -34,31 +34,31 @@ namespace gli
 
 	using std::size_t;
 
-	typedef tvec1<int> extent1d;
-	typedef tvec2<int> extent2d;
-	typedef tvec3<int> extent3d;
-	typedef tvec4<int> extent4d;
+	typedef ivec1 extent1d;
+	typedef ivec2 extent2d;
+	typedef ivec3 extent3d;
+	typedef ivec4 extent4d;
 
 	template <typename T, precision P>
-	inline tvec4<T, P> make_vec4(tvec1<T, P> const & v)
+	inline vec<4, T, P> make_vec4(vec<1, T, P> const & v)
 	{
-		return tvec4<T, P>(v.x, static_cast<T>(0), static_cast<T>(0), static_cast<T>(1));
+		return vec<4, T, P>(v.x, static_cast<T>(0), static_cast<T>(0), static_cast<T>(1));
 	}
 
 	template <typename T, precision P>
-	inline tvec4<T, P> make_vec4(tvec2<T, P> const & v)
+	inline vec<4, T, P> make_vec4(vec<2, T, P> const & v)
 	{
-		return tvec4<T, P>(v.x, v.y, static_cast<T>(0), static_cast<T>(1));
+		return vec<4, T, P>(v.x, v.y, static_cast<T>(0), static_cast<T>(1));
 	}
 
 	template <typename T, precision P>
-	inline tvec4<T, P> make_vec4(tvec3<T, P> const & v)
+	inline vec<4, T, P> make_vec4(vec<3, T, P> const & v)
 	{
-		return tvec4<T, P>(v.x, v.y, v.z, static_cast<T>(1));
+		return vec<4, T, P>(v.x, v.y, v.z, static_cast<T>(1));
 	}
 
 	template <typename T, precision P>
-	inline tvec4<T, P> make_vec4(tvec4<T, P> const & v)
+	inline vec<4, T, P> make_vec4(vec<4, T, P> const & v)
 	{
 		return v;
 	}
diff --git a/test/gtc/gtc_bitfield.cpp b/test/gtc/gtc_bitfield.cpp
index a22ff860..a9346b7a 100644
--- a/test/gtc/gtc_bitfield.cpp
+++ b/test/gtc/gtc_bitfield.cpp
@@ -8,7 +8,7 @@
 
 namespace mask
 {
-	template <typename genType>
+	template<typename genType>
 	struct type
 	{
 		genType		Value;
@@ -195,7 +195,7 @@ namespace mask
 
 namespace bitfieldInterleave3
 {
-	template <typename PARAM, typename RET>
+	template<typename PARAM, typename RET>
 	inline RET refBitfieldInterleave(PARAM x, PARAM y, PARAM z)
 	{
 		RET Result = 0; 
@@ -231,7 +231,7 @@ namespace bitfieldInterleave3
 
 namespace bitfieldInterleave4
 {
-	template <typename PARAM, typename RET>
+	template<typename PARAM, typename RET>
 	inline RET loopBitfieldInterleave(PARAM x, PARAM y, PARAM z, PARAM w)
 	{
 		RET const v[4] = {x, y, z, w};
diff --git a/test/gtc/gtc_epsilon.cpp b/test/gtc/gtc_epsilon.cpp
index 20c59a1a..fcb50ac7 100644
--- a/test/gtc/gtc_epsilon.cpp
+++ b/test/gtc/gtc_epsilon.cpp
@@ -25,7 +25,7 @@ int test_defined()
 	return 0;
 }
 
-template <typename T>
+template<typename T>
 int test_equal()
 {
 	int Error(0);
diff --git a/test/gtc/gtc_integer.cpp b/test/gtc/gtc_integer.cpp
index cbaf5016..302ceec1 100644
--- a/test/gtc/gtc_integer.cpp
+++ b/test/gtc/gtc_integer.cpp
@@ -94,7 +94,7 @@ namespace log2_
 
 			for(std::size_t i = 0; i < Count; ++i)
 			{
-				glm::tvec4<unsigned long, glm::defaultp> Tmp(glm::uninitialize);
+				glm::vec<4, unsigned long, glm::defaultp> Tmp(glm::uninitialize);
 				_BitScanReverse(&Tmp.x, i);
 				_BitScanReverse(&Tmp.y, i);
 				_BitScanReverse(&Tmp.z, i);
@@ -109,7 +109,7 @@ namespace log2_
 
 
 		{
-			std::vector<glm::tvec4<unsigned long, glm::defaultp> > Result;
+			std::vector<glm::vec<4, unsigned long, glm::defaultp> > Result;
 			Result.resize(Count);
 
 			std::clock_t Begin = clock();
diff --git a/test/gtc/gtc_packing.cpp b/test/gtc/gtc_packing.cpp
index fdb8ad59..2e6e23dd 100644
--- a/test/gtc/gtc_packing.cpp
+++ b/test/gtc/gtc_packing.cpp
@@ -529,7 +529,7 @@ int test_packUnorm()
 	{
 		glm::vec2 B(A[i]);
 		glm::u16vec2 C = glm::packUnorm<glm::uint16>(B);
-		glm::vec2 D = glm::unpackUnorm<glm::uint16, float>(C);
+		glm::vec2 D = glm::unpackUnorm<float>(C);
 		Error += glm::all(glm::epsilonEqual(B, D, 1.0f / 255.f)) ? 0 : 1;
 		assert(!Error);
 	}
@@ -550,7 +550,7 @@ int test_packSnorm()
 	{
 		glm::vec2 B(A[i]);
 		glm::i16vec2 C = glm::packSnorm<glm::int16>(B);
-		glm::vec2 D = glm::unpackSnorm<glm::int16, float>(C);
+		glm::vec2 D = glm::unpackSnorm<float>(C);
 		Error += glm::all(glm::epsilonEqual(B, D, 1.0f / 32767.0f * 2.0f)) ? 0 : 1;
 		assert(!Error);
 	}
diff --git a/test/gtc/gtc_round.cpp b/test/gtc/gtc_round.cpp
index 4575066c..b8f44caa 100644
--- a/test/gtc/gtc_round.cpp
+++ b/test/gtc/gtc_round.cpp
@@ -8,7 +8,7 @@
 
 namespace isPowerOfTwo
 {
-	template <typename genType>
+	template<typename genType>
 	struct type
 	{
 		genType		Value;
@@ -146,7 +146,7 @@ namespace isPowerOfTwo
 
 namespace ceilPowerOfTwo_advanced
 {
-	template <typename genIUType>
+	template<typename genIUType>
 	GLM_FUNC_QUALIFIER genIUType highestBitValue(genIUType Value)
 	{
 		genIUType tmp = Value;
@@ -159,13 +159,13 @@ namespace ceilPowerOfTwo_advanced
 		return result;
 	}
 
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER genType ceilPowerOfTwo_loop(genType value)
 	{
 		return glm::isPowerOfTwo(value) ? value : highestBitValue(value) << 1;
 	}
 
-	template <typename genType>
+	template<typename genType>
 	struct type
 	{
 		genType		Value;
@@ -332,7 +332,7 @@ namespace ceilPowerOfTwo
 
 namespace floorMultiple
 {
-	template <typename genType>
+	template<typename genType>
 	struct type
 	{
 		genType		Source;
@@ -372,7 +372,7 @@ namespace floorMultiple
 
 namespace ceilMultiple
 {
-	template <typename genType>
+	template<typename genType>
 	struct type
 	{
 		genType		Source;
diff --git a/test/gtx/gtx_common.cpp b/test/gtx/gtx_common.cpp
index b24d5e04..0ac8e72e 100644
--- a/test/gtx/gtx_common.cpp
+++ b/test/gtx/gtx_common.cpp
@@ -7,7 +7,7 @@
 
 namespace fmod_
 {
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER genType modTrunc(genType a, genType b)
 	{
 		return a - b * glm::trunc(a / b);
diff --git a/test/gtx/gtx_fast_trigonometry.cpp b/test/gtx/gtx_fast_trigonometry.cpp
index 8c5b9ae3..8b9a436b 100644
--- a/test/gtx/gtx_fast_trigonometry.cpp
+++ b/test/gtx/gtx_fast_trigonometry.cpp
@@ -173,15 +173,17 @@ namespace fastAtan
 
 namespace taylorCos
 {
+	using glm::precision;
+	
 	glm::vec4 const AngleShift(0.0f, glm::pi<float>() * 0.5f, glm::pi<float>() * 1.0f, glm::pi<float>() * 1.5f);
 
-	template <typename T, glm::precision P, template <typename, glm::precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> taylorSeriesNewCos(vecType<T, P> const & x)
+	template<glm::length_t L, typename T, precision P, template<glm::length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> taylorSeriesNewCos(vecType<L, T, P> const & x)
 	{
-		vecType<T, P> const Powed2(x * x);
-		vecType<T, P> const Powed4(Powed2 * Powed2);
-		vecType<T, P> const Powed6(Powed4 * Powed2);
-		vecType<T, P> const Powed8(Powed4 * Powed4);
+		vecType<L, T, P> const Powed2(x * x);
+		vecType<L, T, P> const Powed4(Powed2 * Powed2);
+		vecType<L, T, P> const Powed6(Powed4 * Powed2);
+		vecType<L, T, P> const Powed8(Powed4 * Powed4);
 
 		return static_cast<T>(1)
 			- Powed2 * static_cast<T>(0.5)
@@ -190,12 +192,12 @@ namespace taylorCos
 			+ Powed8 * static_cast<T>(2.4801587301587301587301587301587e-5);
 	}
 
-	template <typename T, glm::precision P, template <typename, glm::precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> taylorSeriesNewCos6(vecType<T, P> const & x)
+	template<glm::length_t L, typename T, precision P, template<glm::length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> taylorSeriesNewCos6(vecType<L, T, P> const & x)
 	{
-		vecType<T, P> const Powed2(x * x);
-		vecType<T, P> const Powed4(Powed2 * Powed2);
-		vecType<T, P> const Powed6(Powed4 * Powed2);
+		vecType<L, T, P> const Powed2(x * x);
+		vecType<L, T, P> const Powed4(Powed2 * Powed2);
+		vecType<L, T, P> const Powed6(Powed4 * Powed2);
 
 		return static_cast<T>(1)
 			- Powed2 * static_cast<T>(0.5)
@@ -203,8 +205,8 @@ namespace taylorCos
 			- Powed6 * static_cast<T>(0.00138888888888888888888888888889);
 	}
 
-	template <glm::precision P, template <typename, glm::precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<float, P> fastAbs(vecType<float, P> x)
+	template<glm::length_t L, precision P, template<glm::length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, float, P> fastAbs(vecType<L, float, P> x)
 	{
 		int* Pointer = reinterpret_cast<int*>(&x[0]);
 		Pointer[0] &= 0x7fffffff;
@@ -214,17 +216,17 @@ namespace taylorCos
 		return x;
 	}
 
-	template <typename T, glm::precision P, template <typename, glm::precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> fastCosNew(vecType<T, P> const & x)
+	template<glm::length_t L, typename T, glm::precision P, template<glm::length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> fastCosNew(vecType<L, T, P> const & x)
 	{
-		vecType<T, P> const Angle0_PI(fastAbs(fmod(x + glm::pi<T>(), glm::two_pi<T>()) - glm::pi<T>()));
+		vecType<L, T, P> const Angle0_PI(fastAbs(fmod(x + glm::pi<T>(), glm::two_pi<T>()) - glm::pi<T>()));
 		return taylorSeriesNewCos6(x);
 /*
-		vecType<bool, P> const FirstQuarterPi(lessThanEqual(Angle0_PI, vecType<T, P>(glm::half_pi<T>())));
+		vecType<L, bool, P> const FirstQuarterPi(lessThanEqual(Angle0_PI, vecType<L, T, P>(glm::half_pi<T>())));
 
-		vecType<T, P> const RevertAngle(mix(vecType<T, P>(glm::pi<T>()), vecType<T, P>(0), FirstQuarterPi));
-		vecType<T, P> const ReturnSign(mix(vecType<T, P>(-1), vecType<T, P>(1), FirstQuarterPi));
-		vecType<T, P> const SectionAngle(RevertAngle - Angle0_PI);
+		vecType<L, T, P> const RevertAngle(mix(vecType<L, T, P>(glm::pi<T>()), vecType<L, T, P>(0), FirstQuarterPi));
+		vecType<L, T, P> const ReturnSign(mix(vecType<L, T, P>(-1), vecType<L, T, P>(1), FirstQuarterPi));
+		vecType<L, T, P> const SectionAngle(RevertAngle - Angle0_PI);
 
 		return ReturnSign * taylorSeriesNewCos(SectionAngle);
 */
@@ -252,21 +254,21 @@ namespace taylorCos
 		return Error;
 	}
 
-	template <typename T, glm::precision P, template <typename, glm::precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> deterministic_fmod(vecType<T, P> const & x, T y)
+	template<glm::length_t L, typename T, precision P, template<glm::length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> deterministic_fmod(vecType<L, T, P> const & x, T y)
 	{
 		return x - y * trunc(x / y);
 	}
 
-	template <typename T, glm::precision P, template <typename, glm::precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> fastCosDeterminisctic(vecType<T, P> const & x)
+	template<glm::length_t L, typename T, precision P, template<glm::length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> fastCosDeterminisctic(vecType<L, T, P> const & x)
 	{
-		vecType<T, P> const Angle0_PI(abs(deterministic_fmod(x + glm::pi<T>(), glm::two_pi<T>()) - glm::pi<T>()));
-		vecType<bool, P> const FirstQuarterPi(lessThanEqual(Angle0_PI, vecType<T, P>(glm::half_pi<T>())));
+		vecType<L, T, P> const Angle0_PI(abs(deterministic_fmod(x + glm::pi<T>(), glm::two_pi<T>()) - glm::pi<T>()));
+		vecType<L, bool, P> const FirstQuarterPi(lessThanEqual(Angle0_PI, vecType<L, T, P>(glm::half_pi<T>())));
 
-		vecType<T, P> const RevertAngle(mix(vecType<T, P>(glm::pi<T>()), vecType<T, P>(0), FirstQuarterPi));
-		vecType<T, P> const ReturnSign(mix(vecType<T, P>(-1), vecType<T, P>(1), FirstQuarterPi));
-		vecType<T, P> const SectionAngle(RevertAngle - Angle0_PI);
+		vecType<L, T, P> const RevertAngle(mix(vecType<L, T, P>(glm::pi<T>()), vecType<L, T, P>(0), FirstQuarterPi));
+		vecType<L, T, P> const ReturnSign(mix(vecType<L, T, P>(-1), vecType<L, T, P>(1), FirstQuarterPi));
+		vecType<L, T, P> const SectionAngle(RevertAngle - Angle0_PI);
 
 		return ReturnSign * taylorSeriesNewCos(SectionAngle);
 	}
@@ -293,8 +295,8 @@ namespace taylorCos
 		return Error;
 	}
 
-	template <typename T, glm::precision P, template <typename, glm::precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> taylorSeriesRefCos(vecType<T, P> const & x)
+	template<glm::length_t L, typename T, precision P, template<glm::length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> taylorSeriesRefCos(vecType<L, T, P> const & x)
 	{
 		return static_cast<T>(1)
 			- (x * x) / glm::factorial(static_cast<T>(2))
@@ -303,17 +305,17 @@ namespace taylorCos
 			+ (x * x * x * x * x * x * x * x) / glm::factorial(static_cast<T>(8));
 	}
 
-	template <typename T, glm::precision P, template <typename, glm::precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> fastRefCos(vecType<T, P> const & x)
+	template<glm::length_t L, typename T, precision P, template<glm::length_t, typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<L, T, P> fastRefCos(vecType<L, T, P> const & x)
 	{
-		vecType<T, P> const Angle0_PI(glm::abs(fmod(x + glm::pi<T>(), glm::two_pi<T>()) - glm::pi<T>()));
+		vecType<L, T, P> const Angle0_PI(glm::abs(fmod(x + glm::pi<T>(), glm::two_pi<T>()) - glm::pi<T>()));
 //		return taylorSeriesRefCos(Angle0_PI);
 
-		vecType<bool, P> const FirstQuarterPi(lessThanEqual(Angle0_PI, vecType<T, P>(glm::half_pi<T>())));
+		vecType<L, bool, P> const FirstQuarterPi(lessThanEqual(Angle0_PI, vecType<L, T, P>(glm::half_pi<T>())));
 
-		vecType<T, P> const RevertAngle(mix(vecType<T, P>(glm::pi<T>()), vecType<T, P>(0), FirstQuarterPi));
-		vecType<T, P> const ReturnSign(mix(vecType<T, P>(-1), vecType<T, P>(1), FirstQuarterPi));
-		vecType<T, P> const SectionAngle(RevertAngle - Angle0_PI);
+		vecType<L, T, P> const RevertAngle(mix(vecType<L, T, P>(glm::pi<T>()), vecType<L, T, P>(0), FirstQuarterPi));
+		vecType<L, T, P> const ReturnSign(mix(vecType<L, T, P>(-1), vecType<L, T, P>(1), FirstQuarterPi));
+		vecType<L, T, P> const SectionAngle(RevertAngle - Angle0_PI);
 
 		return ReturnSign * taylorSeriesRefCos(SectionAngle);
 	}
diff --git a/test/gtx/gtx_io.cpp b/test/gtx/gtx_io.cpp
index cc83a27a..f28b464b 100644
--- a/test/gtx/gtx_io.cpp
+++ b/test/gtx/gtx_io.cpp
@@ -7,7 +7,7 @@
 
 namespace
 {
-	template <typename CTy, typename CTr>
+	template<typename CTy, typename CTr>
 	std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>& os, glm::precision const& a)
 	{
 		typename std::basic_ostream<CTy,CTr>::sentry const cerberus(os);
@@ -29,24 +29,24 @@ namespace
 		return os;
 	}
 
-	template <typename U, glm::precision P, typename T, typename CTy, typename CTr>
+	template<typename U, glm::precision P, typename T, typename CTy, typename CTr>
 	std::basic_string<CTy> type_name(std::basic_ostream<CTy,CTr>& os, T const&)
 	{
 		std::basic_ostringstream<CTy,CTr> ostr;
 
 		if      (typeid(T) == typeid(glm::tquat<U,P>))   { ostr << "quat"; }
-		else if (typeid(T) == typeid(glm::tvec2<U,P>))   { ostr << "vec2"; }
-		else if (typeid(T) == typeid(glm::tvec3<U,P>))   { ostr << "vec3"; }
-		else if (typeid(T) == typeid(glm::tvec4<U,P>))   { ostr << "vec4"; }
-		else if (typeid(T) == typeid(glm::tmat2x2<U,P>)) { ostr << "mat2x2"; }
-		else if (typeid(T) == typeid(glm::tmat2x3<U,P>)) { ostr << "mat2x3"; }
-		else if (typeid(T) == typeid(glm::tmat2x4<U,P>)) { ostr << "mat2x4"; }
-		else if (typeid(T) == typeid(glm::tmat3x2<U,P>)) { ostr << "mat3x2"; }
-		else if (typeid(T) == typeid(glm::tmat3x3<U,P>)) { ostr << "mat3x3"; }
-		else if (typeid(T) == typeid(glm::tmat3x4<U,P>)) { ostr << "mat3x4"; }
-		else if (typeid(T) == typeid(glm::tmat4x2<U,P>)) { ostr << "mat4x2"; }
-		else if (typeid(T) == typeid(glm::tmat4x3<U,P>)) { ostr << "mat4x3"; }
-		else if (typeid(T) == typeid(glm::tmat4x4<U,P>)) { ostr << "mat4x4"; }
+		else if (typeid(T) == typeid(glm::vec<2, U,P>))   { ostr << "vec2"; }
+		else if (typeid(T) == typeid(glm::vec<3, U,P>))   { ostr << "vec3"; }
+		else if (typeid(T) == typeid(glm::vec<4, U,P>))   { ostr << "vec4"; }
+		else if (typeid(T) == typeid(glm::mat<2, 2, U,P>)) { ostr << "mat2x2"; }
+		else if (typeid(T) == typeid(glm::mat<2, 3, U,P>)) { ostr << "mat2x3"; }
+		else if (typeid(T) == typeid(glm::mat<2, 4, U,P>)) { ostr << "mat2x4"; }
+		else if (typeid(T) == typeid(glm::mat<3, 2, U,P>)) { ostr << "mat3x2"; }
+		else if (typeid(T) == typeid(glm::mat<3, 3, U,P>)) { ostr << "mat3x3"; }
+		else if (typeid(T) == typeid(glm::mat<3, 4, U,P>)) { ostr << "mat3x4"; }
+		else if (typeid(T) == typeid(glm::mat<4, 2, U,P>)) { ostr << "mat4x2"; }
+		else if (typeid(T) == typeid(glm::mat<4, 3, U,P>)) { ostr << "mat4x3"; }
+		else if (typeid(T) == typeid(glm::mat<4, 4, U,P>)) { ostr << "mat4x4"; }
 		else                                             { ostr << "unknown"; }
 
 		ostr << '<' << typeid(U).name() << ',' << P << '>';
@@ -55,7 +55,7 @@ namespace
 	}
 } // namespace {
 
-template <typename T, glm::precision P, typename OS>
+template<typename T, glm::precision P, typename OS>
 int test_io_quat(OS& os)
 {
 	os << '\n' << typeid(OS).name() << '\n';
@@ -79,14 +79,14 @@ int test_io_quat(OS& os)
 	return 0;
 }
 
-template <typename T, glm::precision P, typename OS>
+template<typename T, glm::precision P, typename OS>
 int test_io_vec(OS& os)
 {
 	os << '\n' << typeid(OS).name() << '\n';
 
-	glm::tvec2<T,P> const v2(0, 1);
-	glm::tvec3<T,P> const v3(2, 3, 4);
-	glm::tvec4<T,P> const v4(5, 6, 7, 8);
+	glm::vec<2, T,P> const v2(0, 1);
+	glm::vec<3, T,P> const v3(2, 3, 4);
+	glm::vec<4, T,P> const v4(5, 6, 7, 8);
 
 	os << type_name<T,P>(os, v2) << ": " << v2 << '\n'
 		<< type_name<T,P>(os, v3) << ": " << v3 << '\n'
@@ -102,49 +102,49 @@ int test_io_vec(OS& os)
 	return 0;
 }
 
-template <typename T, glm::precision P, typename OS>
+template<typename T, glm::precision P, typename OS>
 int test_io_mat(OS& os, glm::io::order_type otype)
 {
 	os << '\n' << typeid(OS).name() << '\n';
 
-	glm::tvec2<T,P> const v2_1( 0,  1);
-	glm::tvec2<T,P> const v2_2( 2,  3);
-	glm::tvec2<T,P> const v2_3( 4,  5);
-	glm::tvec2<T,P> const v2_4( 6,  7);
-	glm::tvec3<T,P> const v3_1( 8,  9, 10);
-	glm::tvec3<T,P> const v3_2(11, 12, 13);
-	glm::tvec3<T,P> const v3_3(14, 15, 16);
-	glm::tvec3<T,P> const v3_4(17, 18, 19);
-	glm::tvec4<T,P> const v4_1(20, 21, 22, 23);
-	glm::tvec4<T,P> const v4_2(24, 25, 26, 27);
-	glm::tvec4<T,P> const v4_3(28, 29, 30, 31);
-	glm::tvec4<T,P> const v4_4(32, 33, 34, 35);
+	glm::vec<2, T,P> const v2_1( 0,  1);
+	glm::vec<2, T,P> const v2_2( 2,  3);
+	glm::vec<2, T,P> const v2_3( 4,  5);
+	glm::vec<2, T,P> const v2_4( 6,  7);
+	glm::vec<3, T,P> const v3_1( 8,  9, 10);
+	glm::vec<3, T,P> const v3_2(11, 12, 13);
+	glm::vec<3, T,P> const v3_3(14, 15, 16);
+	glm::vec<3, T,P> const v3_4(17, 18, 19);
+	glm::vec<4, T,P> const v4_1(20, 21, 22, 23);
+	glm::vec<4, T,P> const v4_2(24, 25, 26, 27);
+	glm::vec<4, T,P> const v4_3(28, 29, 30, 31);
+	glm::vec<4, T,P> const v4_4(32, 33, 34, 35);
 
 	glm::io::basic_format_saver<typename OS::char_type> const iofs(os);
 
 	os << glm::io::precision(2) << glm::io::width(1 + 2 + 1 + 2)
 		<< glm::io::order(otype)
-		<< "mat2x2<" << typeid(T).name() << ',' << P << ">: " << glm::tmat2x2<T,P>(v2_1, v2_2) << '\n'
-		<< "mat2x3<" << typeid(T).name() << ',' << P << ">: " << glm::tmat2x3<T,P>(v3_1, v3_2) << '\n'
-		<< "mat2x4<" << typeid(T).name() << ',' << P << ">: " << glm::tmat2x4<T,P>(v4_1, v4_2) << '\n'
-		<< "mat3x2<" << typeid(T).name() << ',' << P << ">: " << glm::tmat3x2<T,P>(v2_1, v2_2, v2_3) << '\n'
-		<< "mat3x3<" << typeid(T).name() << ',' << P << ">: " << glm::tmat3x3<T,P>(v3_1, v3_2, v3_3) << '\n'
-		<< "mat3x4<" << typeid(T).name() << ',' << P << ">: " << glm::tmat3x4<T,P>(v4_1, v4_2, v4_3) << '\n'
-		<< "mat4x2<" << typeid(T).name() << ',' << P << ">: " << glm::tmat4x2<T,P>(v2_1, v2_2, v2_3, v2_4) << '\n'
-		<< "mat4x3<" << typeid(T).name() << ',' << P << ">: " << glm::tmat4x3<T,P>(v3_1, v3_2, v3_3, v3_4) << '\n'
-		<< "mat4x4<" << typeid(T).name() << ',' << P << ">: " << glm::tmat4x4<T,P>(v4_1, v4_2, v4_3, v4_4) << '\n';
+		<< "mat2x2<" << typeid(T).name() << ',' << P << ">: " << glm::mat<2, 2, T,P>(v2_1, v2_2) << '\n'
+		<< "mat2x3<" << typeid(T).name() << ',' << P << ">: " << glm::mat<2, 3, T,P>(v3_1, v3_2) << '\n'
+		<< "mat2x4<" << typeid(T).name() << ',' << P << ">: " << glm::mat<2, 4, T,P>(v4_1, v4_2) << '\n'
+		<< "mat3x2<" << typeid(T).name() << ',' << P << ">: " << glm::mat<3, 2, T,P>(v2_1, v2_2, v2_3) << '\n'
+		<< "mat3x3<" << typeid(T).name() << ',' << P << ">: " << glm::mat<3, 3, T,P>(v3_1, v3_2, v3_3) << '\n'
+		<< "mat3x4<" << typeid(T).name() << ',' << P << ">: " << glm::mat<3, 4, T,P>(v4_1, v4_2, v4_3) << '\n'
+		<< "mat4x2<" << typeid(T).name() << ',' << P << ">: " << glm::mat<4, 2, T,P>(v2_1, v2_2, v2_3, v2_4) << '\n'
+		<< "mat4x3<" << typeid(T).name() << ',' << P << ">: " << glm::mat<4, 3, T,P>(v3_1, v3_2, v3_3, v3_4) << '\n'
+		<< "mat4x4<" << typeid(T).name() << ',' << P << ">: " << glm::mat<4, 4, T,P>(v4_1, v4_2, v4_3, v4_4) << '\n';
 
 	os << glm::io::unformatted
 		<< glm::io::order(otype)
-		<< "mat2x2<" << typeid(T).name() << ',' << P << ">: " << glm::tmat2x2<T,P>(v2_1, v2_2) << '\n'
-		<< "mat2x3<" << typeid(T).name() << ',' << P << ">: " << glm::tmat2x3<T,P>(v3_1, v3_2) << '\n'
-		<< "mat2x4<" << typeid(T).name() << ',' << P << ">: " << glm::tmat2x4<T,P>(v4_1, v4_2) << '\n'
-		<< "mat3x2<" << typeid(T).name() << ',' << P << ">: " << glm::tmat3x2<T,P>(v2_1, v2_2, v2_3) << '\n'
-		<< "mat3x3<" << typeid(T).name() << ',' << P << ">: " << glm::tmat3x3<T,P>(v3_1, v3_2, v3_3) << '\n'
-		<< "mat3x4<" << typeid(T).name() << ',' << P << ">: " << glm::tmat3x4<T,P>(v4_1, v4_2, v4_3) << '\n'
-		<< "mat4x2<" << typeid(T).name() << ',' << P << ">: " << glm::tmat4x2<T,P>(v2_1, v2_2, v2_3, v2_4) << '\n'
-		<< "mat4x3<" << typeid(T).name() << ',' << P << ">: " << glm::tmat4x3<T,P>(v3_1, v3_2, v3_3, v3_4) << '\n'
-		<< "mat4x4<" << typeid(T).name() << ',' << P << ">: " << glm::tmat4x4<T,P>(v4_1, v4_2, v4_3, v4_4) << '\n';
+		<< "mat2x2<" << typeid(T).name() << ',' << P << ">: " << glm::mat<2, 2, T,P>(v2_1, v2_2) << '\n'
+		<< "mat2x3<" << typeid(T).name() << ',' << P << ">: " << glm::mat<2, 3, T,P>(v3_1, v3_2) << '\n'
+		<< "mat2x4<" << typeid(T).name() << ',' << P << ">: " << glm::mat<2, 4, T,P>(v4_1, v4_2) << '\n'
+		<< "mat3x2<" << typeid(T).name() << ',' << P << ">: " << glm::mat<3, 2, T,P>(v2_1, v2_2, v2_3) << '\n'
+		<< "mat3x3<" << typeid(T).name() << ',' << P << ">: " << glm::mat<3, 3, T,P>(v3_1, v3_2, v3_3) << '\n'
+		<< "mat3x4<" << typeid(T).name() << ',' << P << ">: " << glm::mat<3, 4, T,P>(v4_1, v4_2, v4_3) << '\n'
+		<< "mat4x2<" << typeid(T).name() << ',' << P << ">: " << glm::mat<4, 2, T,P>(v2_1, v2_2, v2_3, v2_4) << '\n'
+		<< "mat4x3<" << typeid(T).name() << ',' << P << ">: " << glm::mat<4, 3, T,P>(v3_1, v3_2, v3_3, v3_4) << '\n'
+		<< "mat4x4<" << typeid(T).name() << ',' << P << ">: " << glm::mat<4, 4, T,P>(v4_1, v4_2, v4_3, v4_4) << '\n';
   
 	return 0;
 }
diff --git a/test/gtx/gtx_type_aligned.cpp b/test/gtx/gtx_type_aligned.cpp
index 9332138e..bc957002 100644
--- a/test/gtx/gtx_type_aligned.cpp
+++ b/test/gtx/gtx_type_aligned.cpp
@@ -79,7 +79,7 @@ int test_decl()
 	return Error;
 }
 
-template <typename genType>
+template<typename genType>
 void print(genType const & Mat0)
 {
 	printf("mat4(\n");