diff --git a/glm/detail/func_matrix.hpp b/glm/detail/func_matrix.hpp
index 655df92d..901c196b 100644
--- a/glm/detail/func_matrix.hpp
+++ b/glm/detail/func_matrix.hpp
@@ -43,9 +43,79 @@
 // Dependencies
 #include "../detail/precision.hpp"
 #include "../detail/setup.hpp"
+#include "../detail/type_mat.hpp"
+#include "../vec2.hpp"
+#include "../vec3.hpp"
+#include "../vec4.hpp"
+#include "../mat2x2.hpp"
+#include "../mat2x3.hpp"
+#include "../mat2x4.hpp"
+#include "../mat3x2.hpp"
+#include "../mat3x3.hpp"
+#include "../mat3x4.hpp"
+#include "../mat4x2.hpp"
+#include "../mat4x3.hpp"
+#include "../mat4x4.hpp"
 
-namespace glm
+namespace glm{
+namespace detail
 {
+	template <typename T, precision P>
+	struct outerProduct_trait<T, P, tvec2, tvec2>
+	{
+		typedef tmat2x2<T, P> type;
+	};
+
+	template <typename T, precision P>
+	struct outerProduct_trait<T, P, tvec2, tvec3>
+	{
+		typedef tmat2x3<T, P> type;
+	};
+
+	template <typename T, precision P>
+	struct outerProduct_trait<T, P, tvec2, tvec4>
+	{
+		typedef tmat2x4<T, P> type;
+	};
+
+	template <typename T, precision P>
+	struct outerProduct_trait<T, P, tvec3, tvec2>
+	{
+		typedef tmat3x2<T, P> type;
+	};
+
+	template <typename T, precision P>
+	struct outerProduct_trait<T, P, tvec3, tvec3>
+	{
+		typedef tmat3x3<T, P> type;
+	};
+
+	template <typename T, precision P>
+	struct outerProduct_trait<T, P, tvec3, tvec4>
+	{
+		typedef tmat3x4<T, P> type;
+	};
+
+	template <typename T, precision P>
+	struct outerProduct_trait<T, P, tvec4, tvec2>
+	{
+		typedef tmat4x2<T, P> type;
+	};
+
+	template <typename T, precision P>
+	struct outerProduct_trait<T, P, tvec4, tvec3>
+	{
+		typedef tmat4x3<T, P> type;
+	};
+
+	template <typename T, precision P>
+	struct outerProduct_trait<T, P, tvec4, tvec4>
+	{
+		typedef tmat4x4<T, P> type;
+	};
+
+}//namespace detail
+
 	/// @addtogroup core_func_matrix
 	/// @{
 
@@ -70,7 +140,7 @@ namespace glm
 	/// 
 	/// @todo Clarify the declaration to specify that matType doesn't have to be provided when used.
 	template <typename T, precision P, template <typename, precision> class vecTypeA, template <typename, precision> class vecTypeB>
-	GLM_FUNC_DECL void outerProduct(vecTypeA<T, P> const & c, vecTypeB<T, P> const & r);
+	GLM_FUNC_DECL typename detail::outerProduct_trait<T, P, vecTypeA, vecTypeB>::type outerProduct(vecTypeA<T, P> const & c, vecTypeB<T, P> const & r);
 
 	/// Returns the transposed matrix of x
 	/// 
diff --git a/glm/detail/func_matrix.inl b/glm/detail/func_matrix.inl
index c6a2c025..3f2fb5ab 100644
--- a/glm/detail/func_matrix.inl
+++ b/glm/detail/func_matrix.inl
@@ -27,18 +27,6 @@
 ///////////////////////////////////////////////////////////////////////////////////
 
 #include "../geometric.hpp"
-#include "../vec2.hpp"
-#include "../vec3.hpp"
-#include "../vec4.hpp"
-#include "type_mat2x2.hpp"
-#include "type_mat2x3.hpp"
-#include "type_mat2x4.hpp"
-#include "type_mat3x2.hpp"
-#include "type_mat3x3.hpp"
-#include "type_mat3x4.hpp"
-#include "type_mat4x2.hpp"
-#include "type_mat4x3.hpp"
-#include "type_mat4x4.hpp"
 #include <limits>
 
 namespace glm{
@@ -55,9 +43,7 @@ namespace detail
 	template <typename T, precision P>
 	struct compute_outerProduct<detail::tvec2, detail::tvec2, T, P>
 	{
-		typedef detail::tmat2x2<T, P> return_type;
-
-		static return_type call(detail::tvec2<T, P> const & c, detail::tvec2<T, P> const & r)
+		GLM_FUNC_QUALIFIER static typename detail::outerProduct_trait<T, P, detail::tvec2, detail::tvec2>::type call(detail::tvec2<T, P> const & c, detail::tvec2<T, P> const & r)
 		{
 			detail::tmat2x2<T, P> m(detail::tmat2x2<T, P>::null);
 			m[0][0] = c[0] * r[0];
@@ -71,9 +57,7 @@ namespace detail
 	template <typename T, precision P>
 	struct compute_outerProduct<detail::tvec3, detail::tvec3, T, P>
 	{
-		typedef detail::tmat3x3<T, P> return_type;
-
-		static return_type call(detail::tvec3<T, P> const & c, detail::tvec3<T, P> const & r)
+		GLM_FUNC_QUALIFIER static typename detail::outerProduct_trait<T, P, detail::tvec3, detail::tvec3>::type call(detail::tvec3<T, P> const & c, detail::tvec3<T, P> const & r)
 		{
 			detail::tmat3x3<T, P> m(detail::tmat3x3<T, P>::null);
 			for(length_t i(0); i < m.length(); ++i)
@@ -85,9 +69,7 @@ namespace detail
 	template <typename T, precision P>
 	struct compute_outerProduct<detail::tvec4, detail::tvec4, T, P>
 	{
-		typedef detail::tmat4x4<T, P> return_type;
-
-		static return_type call(detail::tvec4<T, P> const & c, detail::tvec4<T, P> const & r)
+		GLM_FUNC_QUALIFIER static typename detail::outerProduct_trait<T, P, detail::tvec4, detail::tvec4>::type call(detail::tvec4<T, P> const & c, detail::tvec4<T, P> const & r)
 		{
 			detail::tmat4x4<T, P> m(detail::tmat4x4<T, P>::null);
 			for(length_t i(0); i < m.length(); ++i)
@@ -99,9 +81,7 @@ namespace detail
 	template <typename T, precision P>
 	struct compute_outerProduct<detail::tvec3, detail::tvec2, T, P>
 	{
-		typedef detail::tmat2x3<T, P> return_type;
-
-		static return_type call(detail::tvec3<T, P> const & c, detail::tvec2<T, P> const & r)
+		GLM_FUNC_QUALIFIER static typename detail::outerProduct_trait<T, P, detail::tvec3, detail::tvec2>::type call(detail::tvec3<T, P> const & c, detail::tvec2<T, P> const & r)
 		{
 			detail::tmat2x3<T, P> m(detail::tmat2x3<T, P>::null);
 			m[0][0] = c.x * r.x;
@@ -117,9 +97,7 @@ namespace detail
 	template <typename T, precision P>
 	struct compute_outerProduct<detail::tvec2, detail::tvec3, T, P>
 	{
-		typedef detail::tmat3x2<T, P> return_type;
-
-		static return_type call(detail::tvec2<T, P> const & c, detail::tvec3<T, P> const & r)
+		GLM_FUNC_QUALIFIER static typename detail::outerProduct_trait<T, P, detail::tvec2, detail::tvec3>::type call(detail::tvec2<T, P> const & c, detail::tvec3<T, P> const & r)
 		{
 			detail::tmat3x2<T, P> m(detail::tmat3x2<T, P>::null);
 			m[0][0] = c.x * r.x;
@@ -135,9 +113,7 @@ namespace detail
 	template <typename T, precision P>
 	struct compute_outerProduct<detail::tvec4, detail::tvec2, T, P>
 	{
-		typedef detail::tmat2x4<T, P> return_type;
-
-		static return_type call(detail::tvec4<T, P> const & c, detail::tvec2<T, P> const & r)
+		GLM_FUNC_QUALIFIER static typename detail::outerProduct_trait<T, P, detail::tvec4, detail::tvec2>::type call(detail::tvec4<T, P> const & c, detail::tvec2<T, P> const & r)
 		{
 			detail::tmat2x4<T, P> m(detail::tmat2x4<T, P>::null);
 			m[0][0] = c.x * r.x;
@@ -155,9 +131,7 @@ namespace detail
 	template <typename T, precision P>
 	struct compute_outerProduct<detail::tvec2, detail::tvec4, T, P>
 	{
-		typedef detail::tmat4x2<T, P> return_type;
-
-		static return_type call(detail::tvec2<T, P> const & c, detail::tvec4<T, P> const & r)
+		GLM_FUNC_QUALIFIER static typename detail::outerProduct_trait<T, P, detail::tvec2, detail::tvec4>::type call(detail::tvec2<T, P> const & c, detail::tvec4<T, P> const & r)
 		{
 			detail::tmat4x2<T, P> m(detail::tmat4x2<T, P>::null);
 			m[0][0] = c.x * r.x;
@@ -175,9 +149,7 @@ namespace detail
 	template <typename T, precision P>
 	struct compute_outerProduct<detail::tvec4, detail::tvec3, T, P>
 	{
-		typedef detail::tmat3x4<T, P> return_type;
-
-		static return_type call(detail::tvec4<T, P> const & c, detail::tvec3<T, P> const & r)
+		GLM_FUNC_QUALIFIER static typename detail::outerProduct_trait<T, P, detail::tvec4, detail::tvec3>::type call(detail::tvec4<T, P> const & c, detail::tvec3<T, P> const & r)
 		{
 			detail::tmat3x4<T, P> m(detail::tmat3x4<T, P>::null);
 			m[0][0] = c.x * r.x;
@@ -199,9 +171,7 @@ namespace detail
 	template <typename T, precision P>
 	struct compute_outerProduct<detail::tvec3, detail::tvec4, T, P>
 	{
-		typedef detail::tmat4x3<T, P> return_type;
-
-		static return_type call(detail::tvec3<T, P> const & c, detail::tvec4<T, P> const & r)
+		GLM_FUNC_QUALIFIER static typename detail::outerProduct_trait<T, P, detail::tvec3, detail::tvec4>::type call(detail::tvec3<T, P> const & c, detail::tvec4<T, P> const & r)
 		{
 			detail::tmat4x3<T, P> m(detail::tmat4x3<T, P>::null);
 			m[0][0] = c.x * r.x;
@@ -226,7 +196,7 @@ namespace detail
 	template <typename T, precision P>
 	struct compute_transpose<detail::tmat2x2, T, P>
 	{
-		static detail::tmat2x2<T, P> call(detail::tmat2x2<T, P> const & m)
+		GLM_FUNC_QUALIFIER static detail::tmat2x2<T, P> call(detail::tmat2x2<T, P> const & m)
 		{
 			detail::tmat2x2<T, P> result(detail::tmat2x2<T, P>::_null);
 			result[0][0] = m[0][0];
@@ -240,7 +210,7 @@ namespace detail
 	template <typename T, precision P>
 	struct compute_transpose<detail::tmat2x3, T, P>
 	{
-		static detail::tmat3x2<T, P> call(detail::tmat2x3<T, P> const & m)
+		GLM_FUNC_QUALIFIER static detail::tmat3x2<T, P> call(detail::tmat2x3<T, P> const & m)
 		{
 			detail::tmat3x2<T, P> result(detail::tmat3x2<T, P>::_null);
 			result[0][0] = m[0][0];
@@ -256,7 +226,7 @@ namespace detail
 	template <typename T, precision P>
 	struct compute_transpose<detail::tmat2x4, T, P>
 	{
-		static detail::tmat4x2<T, P> call(detail::tmat2x4<T, P> const & m)
+		GLM_FUNC_QUALIFIER static detail::tmat4x2<T, P> call(detail::tmat2x4<T, P> const & m)
 		{
 			detail::tmat4x2<T, P> result(detail::tmat4x2<T, P>::_null);
 			result[0][0] = m[0][0];
@@ -274,7 +244,7 @@ namespace detail
 	template <typename T, precision P>
 	struct compute_transpose<detail::tmat3x2, T, P>
 	{
-		static detail::tmat2x3<T, P> call(detail::tmat3x2<T, P> const & m)
+		GLM_FUNC_QUALIFIER static detail::tmat2x3<T, P> call(detail::tmat3x2<T, P> const & m)
 		{
 			detail::tmat2x3<T, P> result(detail::tmat2x3<T, P>::_null);
 			result[0][0] = m[0][0];
@@ -290,7 +260,7 @@ namespace detail
 	template <typename T, precision P>
 	struct compute_transpose<detail::tmat3x3, T, P>
 	{
-		static detail::tmat3x3<T, P> call(detail::tmat3x3<T, P> const & m)
+		GLM_FUNC_QUALIFIER static detail::tmat3x3<T, P> call(detail::tmat3x3<T, P> const & m)
 		{
 			detail::tmat3x3<T, P> result(detail::tmat3x3<T, P>::_null);
 			result[0][0] = m[0][0];
@@ -311,7 +281,7 @@ namespace detail
 	template <typename T, precision P>
 	struct compute_transpose<detail::tmat3x4, T, P>
 	{
-		static detail::tmat4x3<T, P> call(detail::tmat3x4<T, P> const & m)
+		GLM_FUNC_QUALIFIER static detail::tmat4x3<T, P> call(detail::tmat3x4<T, P> const & m)
 		{
 			detail::tmat4x3<T, P> result(detail::tmat4x3<T, P>::_null);
 			result[0][0] = m[0][0];
@@ -333,7 +303,7 @@ namespace detail
 	template <typename T, precision P>
 	struct compute_transpose<detail::tmat4x2, T, P>
 	{
-		static detail::tmat2x4<T, P> call(detail::tmat4x2<T, P> const & m)
+		GLM_FUNC_QUALIFIER static detail::tmat2x4<T, P> call(detail::tmat4x2<T, P> const & m)
 		{
 			detail::tmat2x4<T, P> result(detail::tmat2x4<T, P>::_null);
 			result[0][0] = m[0][0];
@@ -351,7 +321,7 @@ namespace detail
 	template <typename T, precision P>
 	struct compute_transpose<detail::tmat4x3, T, P>
 	{
-		static detail::tmat3x4<T, P> call(detail::tmat4x3<T, P> const & m)
+		GLM_FUNC_QUALIFIER static detail::tmat3x4<T, P> call(detail::tmat4x3<T, P> const & m)
 		{
 			detail::tmat3x4<T, P> result(detail::tmat3x4<T, P>::_null);
 			result[0][0] = m[0][0];
@@ -373,7 +343,7 @@ namespace detail
 	template <typename T, precision P>
 	struct compute_transpose<detail::tmat4x4, T, P>
 	{
-		static detail::tmat4x4<T, P> call(detail::tmat4x4<T, P> const & m)
+		GLM_FUNC_QUALIFIER static detail::tmat4x4<T, P> call(detail::tmat4x4<T, P> const & m)
 		{
 			detail::tmat4x4<T, P> result(detail::tmat4x4<T, P>::_null);
 			result[0][0] = m[0][0];
@@ -405,7 +375,7 @@ namespace detail
 	template <typename T, precision P>
 	struct compute_determinant<detail::tmat2x2, T, P>
 	{
-		static T call(detail::tmat2x2<T, P> const & m)
+		GLM_FUNC_QUALIFIER static T call(detail::tmat2x2<T, P> const & m)
 		{
 			return m[0][0] * m[1][1] - m[1][0] * m[0][1];
 		}
@@ -414,7 +384,7 @@ namespace detail
 	template <typename T, precision P>
 	struct compute_determinant<detail::tmat3x3, T, P>
 	{
-		static T call(detail::tmat3x3<T, P> const & m)
+		GLM_FUNC_QUALIFIER static T call(detail::tmat3x3<T, P> const & m)
 		{
 			return
 				+ m[0][0] * (m[1][1] * m[2][2] - m[2][1] * m[1][2])
@@ -426,7 +396,7 @@ namespace detail
 	template <typename T, precision P>
 	struct compute_determinant<detail::tmat4x4, T, P>
 	{
-		static T call(detail::tmat4x4<T, P> const & m)
+		GLM_FUNC_QUALIFIER static T call(detail::tmat4x4<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];
@@ -460,7 +430,7 @@ namespace detail
 	}
 
 	template<template <class, precision> class vecTypeA, template <class, precision> class vecTypeB, typename T, precision P>
-	GLM_FUNC_QUALIFIER typename detail::compute_outerProduct<vecTypeA, vecTypeB, T, P>::return_type outerProduct(vecTypeA<T, P> const & c, vecTypeB<T, P> const & r)
+	GLM_FUNC_QUALIFIER typename detail::outerProduct_trait<T, P, vecTypeA, vecTypeB>::type outerProduct(vecTypeA<T, P> const & c, vecTypeB<T, P> const & r)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'outerProduct' only accept floating-point inputs");
 		return detail::compute_outerProduct<vecTypeA, vecTypeB, T, P>::call(c, r);
diff --git a/glm/detail/type_mat.hpp b/glm/detail/type_mat.hpp
index a46c4068..94105240 100644
--- a/glm/detail/type_mat.hpp
+++ b/glm/detail/type_mat.hpp
@@ -34,6 +34,9 @@
 namespace glm{
 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;
@@ -44,8 +47,8 @@ namespace detail
 	template <typename T, precision P> struct tmat4x3;
 	template <typename T, precision P> struct tmat4x4;
 
-	template <class colType, typename rowType>
-	struct mat_trait{};
+	template <typename T, precision P, template <class, precision> class colType, template <class, precision> class rowType>
+	struct outerProduct_trait{};
 
 	template <template <class, precision> class matType, typename T, precision P>
 	struct compute_inverse{};
diff --git a/glm/mat2x2.hpp b/glm/mat2x2.hpp
index df72bab1..57f7f808 100644
--- a/glm/mat2x2.hpp
+++ b/glm/mat2x2.hpp
@@ -31,4 +31,50 @@
 
 #include "detail/type_mat2x2.hpp"
 
+namespace glm
+{
+	/// 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 detail::tmat2x2<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 detail::tmat2x2<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 detail::tmat2x2<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 detail::tmat2x2<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 detail::tmat2x2<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 detail::tmat2x2<float, highp>		highp_mat2x2;
+
+}//namespace glm
+
 #endif//GLM_MAT2X2_INCLUDED
diff --git a/glm/mat2x3.hpp b/glm/mat2x3.hpp
index a5b0ffce..ea020b06 100644
--- a/glm/mat2x3.hpp
+++ b/glm/mat2x3.hpp
@@ -31,4 +31,29 @@
 
 #include "detail/type_mat2x3.hpp"
 
+namespace glm
+{
+	/// 2 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 detail::tmat2x3<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 detail::tmat2x3<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 detail::tmat2x3<float, highp>		highp_mat2x3;
+
+}//namespace glm
+
 #endif//GLM_MAT2X3_INCLUDED
diff --git a/glm/mat2x4.hpp b/glm/mat2x4.hpp
index ca539d9d..24997012 100644
--- a/glm/mat2x4.hpp
+++ b/glm/mat2x4.hpp
@@ -31,4 +31,29 @@
 
 #include "detail/type_mat2x4.hpp"
 
+namespace glm
+{
+	/// 2 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 detail::tmat2x4<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 detail::tmat2x4<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 detail::tmat2x4<float, highp>		highp_mat2x4;
+
+}//namespace glm
+
 #endif//GLM_MAT2X4_INCLUDED
diff --git a/glm/mat3x2.hpp b/glm/mat3x2.hpp
index 90d07c6f..47c1ca4e 100644
--- a/glm/mat3x2.hpp
+++ b/glm/mat3x2.hpp
@@ -31,4 +31,29 @@
 
 #include "detail/type_mat3x2.hpp"
 
+namespace glm
+{
+	/// 3 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 detail::tmat3x2<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 detail::tmat3x2<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 detail::tmat3x2<float, highp>		highp_mat3x2;
+
+}//namespace
+
 #endif//GLM_MAT3X2_INCLUDED
diff --git a/glm/mat3x3.hpp b/glm/mat3x3.hpp
index bb0a1ce7..5d7659c9 100644
--- a/glm/mat3x3.hpp
+++ b/glm/mat3x3.hpp
@@ -31,4 +31,50 @@
 
 #include "detail/type_mat3x3.hpp"
 
+namespace glm
+{
+	/// 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 detail::tmat3x3<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 detail::tmat3x3<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 detail::tmat3x3<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 detail::tmat3x3<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 detail::tmat3x3<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 detail::tmat3x3<float, highp>		highp_mat3x3;
+
+}//namespace glm
+
 #endif//GLM_MAT3X3_INCLUDED
diff --git a/glm/mat3x4.hpp b/glm/mat3x4.hpp
index 61be0864..03b5fee3 100644
--- a/glm/mat3x4.hpp
+++ b/glm/mat3x4.hpp
@@ -31,4 +31,29 @@
 
 #include "detail/type_mat3x4.hpp"
 
+namespace glm
+{
+	/// 3 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 detail::tmat3x4<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 detail::tmat3x4<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 detail::tmat3x4<float, highp>		highp_mat3x4;
+
+}//namespace glm
+
 #endif//GLM_MAT3X4_INCLUDED
diff --git a/glm/mat4x2.hpp b/glm/mat4x2.hpp
index 96877843..1e4671a0 100644
--- a/glm/mat4x2.hpp
+++ b/glm/mat4x2.hpp
@@ -31,4 +31,29 @@
 
 #include "detail/type_mat4x2.hpp"
 
+namespace glm
+{
+	/// 4 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 detail::tmat4x2<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 detail::tmat4x2<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 detail::tmat4x2<float, highp>		highp_mat4x2;
+
+}//namespace glm
+
 #endif//GLM_MAT4X2_INCLUDED
diff --git a/glm/mat4x3.hpp b/glm/mat4x3.hpp
index b27f0294..14ecee92 100644
--- a/glm/mat4x3.hpp
+++ b/glm/mat4x3.hpp
@@ -31,4 +31,29 @@
 
 #include "detail/type_mat4x3.hpp"
 
+namespace glm
+{
+	/// 4 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 detail::tmat4x3<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 detail::tmat4x3<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 detail::tmat4x3<float, highp>		highp_mat4x3;
+
+}//namespace glm
+
 #endif//GLM_MAT4X3_INCLUDED
diff --git a/glm/mat4x4.hpp b/glm/mat4x4.hpp
index d3d3fc4c..7e97af69 100644
--- a/glm/mat4x4.hpp
+++ b/glm/mat4x4.hpp
@@ -31,4 +31,50 @@
 
 #include "detail/type_mat4x4.hpp"
 
+namespace glm
+{
+	/// 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 detail::tmat4x4<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 detail::tmat4x4<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 detail::tmat4x4<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 detail::tmat4x4<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 detail::tmat4x4<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 detail::tmat4x4<float, highp>		highp_mat4x4;
+
+}//namespace glm
+
 #endif//GLM_MAT4X4_INCLUDED
diff --git a/readme.txt b/readme.txt
index aca90c00..7c472af2 100644
--- a/readme.txt
+++ b/readme.txt
@@ -47,6 +47,7 @@ GLM 0.9.5.1: 2014-01-11
 - Fixed inverse link error when using namespace glm; (#147)
 - Optimized matrix inverse and division code (#149)
 - Added intersectRayPlane function (#153)
+- Fixed outerProduct return type (#155)
 
 ================================================================================
 GLM 0.9.5.0: 2013-12-25