diff --git a/glm/core/setup.hpp b/glm/core/setup.hpp
index 6945bbc6..a90095fb 100644
--- a/glm/core/setup.hpp
+++ b/glm/core/setup.hpp
@@ -400,9 +400,11 @@
 // User defines: GLM_FORCE_INLINE GLM_FORCE_CUDA
 
 #if(defined(GLM_FORCE_CUDA) || (defined(GLM_COMPILER) && (GLM_COMPILER >= GLM_COMPILER_CUDA30)))
-#   define GLM_CUDA_QUALIFIER __device__ __host__ 
+#   define GLM_CUDA_FUNC_DEF __device__ __host__ 
+#	define GLM_CUDA_FUNC_DECL __device__ __host__ 
 #else
-#   define GLM_CUDA_QUALIFIER
+#   define GLM_CUDA_FUNC_DEF
+#	define GLM_CUDA_FUNC_DECL
 #endif
 
 #if(defined(GLM_FORCE_INLINE))
@@ -417,7 +419,8 @@
 #   define GLM_INLINE inline
 #endif//defined(GLM_FORCE_INLINE)
 
-#define GLM_FUNC_QUALIFIER GLM_CUDA_QUALIFIER GLM_INLINE
+#define GLM_FUNC_DECL GLM_CUDA_FUNC_DECL
+#define GLM_FUNC_QUALIFIER GLM_CUDA_FUNC_DEF GLM_INLINE
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // Swizzle operators
diff --git a/glm/core/type_half.hpp b/glm/core/type_half.hpp
index cc8fed60..00a90157 100644
--- a/glm/core/type_half.hpp
+++ b/glm/core/type_half.hpp
@@ -33,30 +33,30 @@ namespace glm
 		{
 		public: 
 			// Constructors
-			thalf();
-			thalf(thalf const & s);
+			GLM_FUNC_DECL thalf();
+			GLM_FUNC_DECL thalf(thalf const & s);
 			
 			template <typename U>
-			explicit thalf(U const & s);
+			GLM_FUNC_DECL explicit thalf(U const & s);
 
 			// Cast
 			//operator float();
-			operator float() const;
+			GLM_FUNC_DECL operator float() const;
 			//operator double();
 			//operator double() const;
 
 			// Unary updatable operators
-			thalf& operator= (thalf const & s);
-			thalf& operator+=(thalf const & s);
-			thalf& operator-=(thalf const & s);
-			thalf& operator*=(thalf const & s);
-			thalf& operator/=(thalf const & s);
-			thalf& operator++();
-			thalf& operator--();
+			GLM_FUNC_DECL thalf& operator= (thalf const & s);
+			GLM_FUNC_DECL thalf& operator+=(thalf const & s);
+			GLM_FUNC_DECL thalf& operator-=(thalf const & s);
+			GLM_FUNC_DECL thalf& operator*=(thalf const & s);
+			GLM_FUNC_DECL thalf& operator/=(thalf const & s);
+			GLM_FUNC_DECL thalf& operator++();
+			GLM_FUNC_DECL thalf& operator--();
 	
-			float toFloat() const{return toFloat32(data);}
+			GLM_FUNC_DECL float toFloat() const{return toFloat32(data);}
 
-			hdata _data() const{return data;}
+			GLM_FUNC_DECL hdata _data() const{return data;}
 
 		private:
 			hdata data;
diff --git a/glm/core/type_mat2x2.hpp b/glm/core/type_mat2x2.hpp
index aecd36e0..aade1ef4 100644
--- a/glm/core/type_mat2x2.hpp
+++ b/glm/core/type_mat2x2.hpp
@@ -45,15 +45,15 @@ namespace glm
 			typedef std::size_t size_type;
 			typedef tvec2<T> col_type;
 			typedef tvec2<T> row_type;
-			static size_type col_size();
-			static size_type row_size();
+			static GLM_FUNC_DECL size_type col_size();
+			static GLM_FUNC_DECL size_type row_size();
 
 			typedef tmat2x2<T> type;
 			typedef tmat2x2<T> transpose_type;
 
 		public:
 			// Implementation detail
-			tmat2x2<T> _inverse() const;
+			GLM_FUNC_DECL tmat2x2<T> _inverse() const;
 
 		private:
 			// Data 
@@ -61,62 +61,62 @@ namespace glm
 
 		public:
 			// Constructors
-			tmat2x2();
-			tmat2x2(
+			GLM_FUNC_DECL tmat2x2();
+			GLM_FUNC_DECL tmat2x2(
 				tmat2x2 const & m);
 
-			explicit tmat2x2(
+			GLM_FUNC_DECL explicit tmat2x2(
 				ctor Null);
-			explicit tmat2x2(
+			GLM_FUNC_DECL explicit tmat2x2(
 				value_type const & x);
-			explicit tmat2x2(
+			GLM_FUNC_DECL explicit tmat2x2(
 				value_type const & x1, value_type const & y1, 
 				value_type const & x2, value_type const & y2);
-			explicit tmat2x2(
+			GLM_FUNC_DECL explicit tmat2x2(
 				col_type const & v1, 
 				col_type const & v2);
 
 			// Conversions
 			template <typename U> 
-			explicit tmat2x2(tmat2x2<U> const & m);
+			GLM_FUNC_DECL explicit tmat2x2(tmat2x2<U> const & m);
 
-			explicit tmat2x2(tmat3x3<T> const & x);
-			explicit tmat2x2(tmat4x4<T> const & x);
-			explicit tmat2x2(tmat2x3<T> const & x);
-			explicit tmat2x2(tmat3x2<T> const & x);
-			explicit tmat2x2(tmat2x4<T> const & x);
-			explicit tmat2x2(tmat4x2<T> const & x);
-			explicit tmat2x2(tmat3x4<T> const & x);
-			explicit tmat2x2(tmat4x3<T> const & x);
+			GLM_FUNC_DECL explicit tmat2x2(tmat3x3<T> const & x);
+			GLM_FUNC_DECL explicit tmat2x2(tmat4x4<T> const & x);
+			GLM_FUNC_DECL explicit tmat2x2(tmat2x3<T> const & x);
+			GLM_FUNC_DECL explicit tmat2x2(tmat3x2<T> const & x);
+			GLM_FUNC_DECL explicit tmat2x2(tmat2x4<T> const & x);
+			GLM_FUNC_DECL explicit tmat2x2(tmat4x2<T> const & x);
+			GLM_FUNC_DECL explicit tmat2x2(tmat3x4<T> const & x);
+			GLM_FUNC_DECL explicit tmat2x2(tmat4x3<T> const & x);
 
 			//////////////////////////////////////
 			// Accesses
 
-			col_type & operator[](size_type i);
-			col_type const & operator[](size_type i) const;
+			GLM_FUNC_DECL col_type & operator[](size_type i);
+			GLM_FUNC_DECL col_type const & operator[](size_type i) const;
 
 			// Unary updatable operators
-			tmat2x2<T> & operator=(tmat2x2<T> const & m);
+			GLM_FUNC_DECL tmat2x2<T> & operator=(tmat2x2<T> const & m);
 			template <typename U> 
-			tmat2x2<T> & operator=(tmat2x2<U> const & m);
+			GLM_FUNC_DECL tmat2x2<T> & operator=(tmat2x2<U> const & m);
 			template <typename U> 
-			tmat2x2<T> & operator+=(U const & s);
+			GLM_FUNC_DECL tmat2x2<T> & operator+=(U const & s);
 			template <typename U> 
-			tmat2x2<T> & operator+=(tmat2x2<U> const & m);
+			GLM_FUNC_DECL tmat2x2<T> & operator+=(tmat2x2<U> const & m);
 			template <typename U> 
-			tmat2x2<T> & operator-=(U const & s);
+			GLM_FUNC_DECL tmat2x2<T> & operator-=(U const & s);
 			template <typename U> 
-			tmat2x2<T> & operator-=(tmat2x2<U> const & m);
+			GLM_FUNC_DECL tmat2x2<T> & operator-=(tmat2x2<U> const & m);
 			template <typename U> 
-			tmat2x2<T> & operator*=(U const & s);
+			GLM_FUNC_DECL tmat2x2<T> & operator*=(U const & s);
 			template <typename U> 
-			tmat2x2<T> & operator*=(tmat2x2<U> const & m);
+			GLM_FUNC_DECL tmat2x2<T> & operator*=(tmat2x2<U> const & m);
 			template <typename U> 
-			tmat2x2<T> & operator/=(U const & s);
+			GLM_FUNC_DECL tmat2x2<T> & operator/=(U const & s);
 			template <typename U> 
-			tmat2x2<T> & operator/=(tmat2x2<U> const & m);
-			tmat2x2<T> & operator++();
-			tmat2x2<T> & operator--();
+			GLM_FUNC_DECL tmat2x2<T> & operator/=(tmat2x2<U> const & m);
+			GLM_FUNC_DECL tmat2x2<T> & operator++();
+			GLM_FUNC_DECL tmat2x2<T> & operator--();
 		};
 
 		// Binary operators
diff --git a/glm/core/type_mat2x3.hpp b/glm/core/type_mat2x3.hpp
index 647d1ebe..ed87f9e2 100644
--- a/glm/core/type_mat2x3.hpp
+++ b/glm/core/type_mat2x3.hpp
@@ -45,8 +45,8 @@ namespace glm
 			typedef std::size_t size_type;
 			typedef tvec3<T> col_type;
 			typedef tvec2<T> row_type;
-			static size_type col_size();
-			static size_type row_size();
+			static GLM_FUNC_DECL size_type col_size();
+			static GLM_FUNC_DECL size_type row_size();
 
 			typedef tmat2x3<T> type;
 			typedef tmat3x2<T> transpose_type;
@@ -57,58 +57,58 @@ namespace glm
 
 		public:
 			// Constructors
-			tmat2x3();
-			tmat2x3(tmat2x3 const & m);
+			GLM_FUNC_DECL tmat2x3();
+			GLM_FUNC_DECL tmat2x3(tmat2x3 const & m);
 
-			explicit tmat2x3(
+			GLM_FUNC_DECL explicit tmat2x3(
 				ctor);
-			explicit tmat2x3(
+			GLM_FUNC_DECL explicit tmat2x3(
 				value_type const & s);
-			explicit tmat2x3(
+			GLM_FUNC_DECL explicit tmat2x3(
 				value_type const & x0, value_type const & y0, value_type const & z0,
 				value_type const & x1, value_type const & y1, value_type const & z1);
-			explicit tmat2x3(
+			GLM_FUNC_DECL explicit tmat2x3(
 				col_type const & v0, 
 				col_type const & v1);
 
 			// Conversion
 			template <typename U> 
-			explicit tmat2x3(tmat2x3<U> const & m);
+			GLM_FUNC_DECL explicit tmat2x3(tmat2x3<U> const & m);
 
-			explicit tmat2x3(tmat2x2<T> const & x);
-			explicit tmat2x3(tmat3x3<T> const & x);
-			explicit tmat2x3(tmat4x4<T> const & x);
-			explicit tmat2x3(tmat2x4<T> const & x);
-			explicit tmat2x3(tmat3x2<T> const & x);
-			explicit tmat2x3(tmat3x4<T> const & x);
-			explicit tmat2x3(tmat4x2<T> const & x);
-			explicit tmat2x3(tmat4x3<T> const & x);
+			GLM_FUNC_DECL explicit tmat2x3(tmat2x2<T> const & x);
+			GLM_FUNC_DECL explicit tmat2x3(tmat3x3<T> const & x);
+			GLM_FUNC_DECL explicit tmat2x3(tmat4x4<T> const & x);
+			GLM_FUNC_DECL explicit tmat2x3(tmat2x4<T> const & x);
+			GLM_FUNC_DECL explicit tmat2x3(tmat3x2<T> const & x);
+			GLM_FUNC_DECL explicit tmat2x3(tmat3x4<T> const & x);
+			GLM_FUNC_DECL explicit tmat2x3(tmat4x2<T> const & x);
+			GLM_FUNC_DECL explicit tmat2x3(tmat4x3<T> const & x);
 
 			// Accesses
 			col_type & operator[](size_type i);
 			col_type const & operator[](size_type i) const;
 
 			// Unary updatable operators
-			tmat2x3<T> & operator=  (tmat2x3<T> const & m);
+			GLM_FUNC_DECL tmat2x3<T> & operator=  (tmat2x3<T> const & m);
 			template <typename U> 
-			tmat2x3<T> & operator=  (tmat2x3<U> const & m);
+			GLM_FUNC_DECL tmat2x3<T> & operator=  (tmat2x3<U> const & m);
 			template <typename U> 
-			tmat2x3<T> & operator+= (U const & s);
+			GLM_FUNC_DECL tmat2x3<T> & operator+= (U const & s);
 			template <typename U> 
-			tmat2x3<T> & operator+= (tmat2x3<U> const & m);
+			GLM_FUNC_DECL tmat2x3<T> & operator+= (tmat2x3<U> const & m);
 			template <typename U> 
-			tmat2x3<T> & operator-= (U const & s);
+			GLM_FUNC_DECL tmat2x3<T> & operator-= (U const & s);
 			template <typename U> 
-			tmat2x3<T> & operator-= (tmat2x3<U> const & m);
+			GLM_FUNC_DECL tmat2x3<T> & operator-= (tmat2x3<U> const & m);
 			template <typename U> 
-			tmat2x3<T> & operator*= (U const & s);
+			GLM_FUNC_DECL tmat2x3<T> & operator*= (U const & s);
 			template <typename U> 
-			tmat2x3<T> & operator*= (tmat2x3<U> const & m);
+			GLM_FUNC_DECL tmat2x3<T> & operator*= (tmat2x3<U> const & m);
 			template <typename U> 
-			tmat2x3<T> & operator/= (U const & s);
+			GLM_FUNC_DECL tmat2x3<T> & operator/= (U const & s);
 
-			tmat2x3<T> & operator++ ();
-			tmat2x3<T> & operator-- ();
+			GLM_FUNC_DECL tmat2x3<T> & operator++ ();
+			GLM_FUNC_DECL tmat2x3<T> & operator-- ();
 		};
 
 		// Binary operators
diff --git a/glm/core/type_mat2x4.hpp b/glm/core/type_mat2x4.hpp
index e0c00ffb..a14cc033 100644
--- a/glm/core/type_mat2x4.hpp
+++ b/glm/core/type_mat2x4.hpp
@@ -45,8 +45,8 @@ namespace glm
 			typedef std::size_t size_type;
 			typedef tvec4<T> col_type;
 			typedef tvec2<T> row_type;
-			static size_type col_size();
-			static size_type row_size();
+			static GLM_FUNC_DECL size_type col_size();
+			static GLM_FUNC_DECL size_type row_size();
 
 			typedef tmat2x4<T> type;
 			typedef tmat4x2<T> transpose_type;
@@ -57,58 +57,58 @@ namespace glm
 
 		public:
 			// Constructors
-			tmat2x4();
-			tmat2x4(tmat2x4 const & m);
+			GLM_FUNC_DECL tmat2x4();
+			GLM_FUNC_DECL tmat2x4(tmat2x4 const & m);
 
-			explicit tmat2x4(
+			GLM_FUNC_DECL explicit tmat2x4(
 				ctor);
-			explicit tmat2x4(
+			GLM_FUNC_DECL explicit tmat2x4(
 				value_type const & s);
-			explicit tmat2x4(
+			GLM_FUNC_DECL explicit tmat2x4(
 				value_type const & x0, value_type const & y0, value_type const & z0, value_type const & w0,
 				value_type const & x1, value_type const & y1, value_type const & z1, value_type const & w1);
-			explicit tmat2x4(
+			GLM_FUNC_DECL explicit tmat2x4(
 				col_type const & v0, 
 				col_type const & v1);
 
 			// Conversion
 			template <typename U> 
-			explicit tmat2x4(tmat2x4<U> const & m);
+			GLM_FUNC_DECL explicit tmat2x4(tmat2x4<U> const & m);
 
-			explicit tmat2x4(tmat2x2<T> const & x);
-			explicit tmat2x4(tmat3x3<T> const & x);
-			explicit tmat2x4(tmat4x4<T> const & x);
-			explicit tmat2x4(tmat2x3<T> const & x);
-			explicit tmat2x4(tmat3x2<T> const & x);
-			explicit tmat2x4(tmat3x4<T> const & x);
-			explicit tmat2x4(tmat4x2<T> const & x);
-			explicit tmat2x4(tmat4x3<T> const & x);
+			GLM_FUNC_DECL explicit tmat2x4(tmat2x2<T> const & x);
+			GLM_FUNC_DECL explicit tmat2x4(tmat3x3<T> const & x);
+			GLM_FUNC_DECL explicit tmat2x4(tmat4x4<T> const & x);
+			GLM_FUNC_DECL explicit tmat2x4(tmat2x3<T> const & x);
+			GLM_FUNC_DECL explicit tmat2x4(tmat3x2<T> const & x);
+			GLM_FUNC_DECL explicit tmat2x4(tmat3x4<T> const & x);
+			GLM_FUNC_DECL explicit tmat2x4(tmat4x2<T> const & x);
+			GLM_FUNC_DECL explicit tmat2x4(tmat4x3<T> const & x);
 
 			// Accesses
-			col_type & operator[](size_type i);
-			col_type const & operator[](size_type i) const;
+			GLM_FUNC_DECL col_type & operator[](size_type i);
+			GLM_FUNC_DECL col_type const & operator[](size_type i) const;
 
 			// Unary updatable operators
-			tmat2x4<T>& operator=  (tmat2x4<T> const & m);
+			GLM_FUNC_DECL tmat2x4<T>& operator=  (tmat2x4<T> const & m);
 			template <typename U> 
-			tmat2x4<T>& operator=  (tmat2x4<U> const & m);
+			GLM_FUNC_DECL tmat2x4<T>& operator=  (tmat2x4<U> const & m);
 			template <typename U> 
-			tmat2x4<T>& operator+= (U const & s);
+			GLM_FUNC_DECL tmat2x4<T>& operator+= (U const & s);
 			template <typename U> 
-			tmat2x4<T>& operator+= (tmat2x4<U> const & m);
+			GLM_FUNC_DECL tmat2x4<T>& operator+= (tmat2x4<U> const & m);
 			template <typename U> 
-			tmat2x4<T>& operator-= (U const & s);
+			GLM_FUNC_DECL tmat2x4<T>& operator-= (U const & s);
 			template <typename U> 
-			tmat2x4<T>& operator-= (tmat2x4<U> const & m);
+			GLM_FUNC_DECL tmat2x4<T>& operator-= (tmat2x4<U> const & m);
 			template <typename U> 
-			tmat2x4<T>& operator*= (U const & s);
+			GLM_FUNC_DECL tmat2x4<T>& operator*= (U const & s);
 			template <typename U> 
-			tmat2x4<T>& operator*= (tmat2x4<U> const & m);
+			GLM_FUNC_DECL tmat2x4<T>& operator*= (tmat2x4<U> const & m);
 			template <typename U> 
-			tmat2x4<T>& operator/= (U const & s);
+			GLM_FUNC_DECL tmat2x4<T>& operator/= (U const & s);
 
-			tmat2x4<T>& operator++ ();
-			tmat2x4<T>& operator-- ();
+			GLM_FUNC_DECL tmat2x4<T>& operator++ ();
+			GLM_FUNC_DECL tmat2x4<T>& operator-- ();
 		};
 
 		// Binary operators
diff --git a/glm/core/type_mat3x2.hpp b/glm/core/type_mat3x2.hpp
index 5a2bd8f0..3457b72f 100644
--- a/glm/core/type_mat3x2.hpp
+++ b/glm/core/type_mat3x2.hpp
@@ -45,8 +45,8 @@ namespace glm
 			typedef std::size_t size_type;
 			typedef tvec2<T> col_type;
 			typedef tvec3<T> row_type;
-			static size_type col_size();
-			static size_type row_size();
+			static GLM_FUNC_DECL size_type col_size();
+			static GLM_FUNC_DECL size_type row_size();
 
 			typedef tmat3x2<T> type;
 			typedef tmat2x3<T> transpose_type;
@@ -57,60 +57,60 @@ namespace glm
 
 		public:
 			// Constructors
-			tmat3x2();
-			tmat3x2(tmat3x2 const & m);
+			GLM_FUNC_DECL tmat3x2();
+			GLM_FUNC_DECL tmat3x2(tmat3x2 const & m);
 
-			explicit tmat3x2(
+			GLM_FUNC_DECL explicit tmat3x2(
 				ctor);
-			explicit tmat3x2(
+			GLM_FUNC_DECL explicit tmat3x2(
 				value_type const & s);
-			explicit tmat3x2(
+			GLM_FUNC_DECL explicit tmat3x2(
 				value_type const & x0, value_type const & y0,
 				value_type const & x1, value_type const & y1,
 				value_type const & x2, value_type const & y2);
-			explicit tmat3x2(
+			GLM_FUNC_DECL explicit tmat3x2(
 				col_type const & v0, 
 				col_type const & v1,
 				col_type const & v2);
 
 			// Conversion
 			template <typename U> 
-			explicit tmat3x2(tmat3x2<U> const & m);
+			GLM_FUNC_DECL explicit tmat3x2(tmat3x2<U> const & m);
 
-			explicit tmat3x2(tmat2x2<T> const & x);
-			explicit tmat3x2(tmat3x3<T> const & x);
-			explicit tmat3x2(tmat4x4<T> const & x);
-			explicit tmat3x2(tmat2x3<T> const & x);
-			explicit tmat3x2(tmat2x4<T> const & x);
-			explicit tmat3x2(tmat3x4<T> const & x);
-			explicit tmat3x2(tmat4x2<T> const & x);
-			explicit tmat3x2(tmat4x3<T> const & x);
+			GLM_FUNC_DECL explicit tmat3x2(tmat2x2<T> const & x);
+			GLM_FUNC_DECL explicit tmat3x2(tmat3x3<T> const & x);
+			GLM_FUNC_DECL explicit tmat3x2(tmat4x4<T> const & x);
+			GLM_FUNC_DECL explicit tmat3x2(tmat2x3<T> const & x);
+			GLM_FUNC_DECL explicit tmat3x2(tmat2x4<T> const & x);
+			GLM_FUNC_DECL explicit tmat3x2(tmat3x4<T> const & x);
+			GLM_FUNC_DECL explicit tmat3x2(tmat4x2<T> const & x);
+			GLM_FUNC_DECL explicit tmat3x2(tmat4x3<T> const & x);
 
 			// Accesses
-			col_type & operator[](size_type i);
-			col_type const & operator[](size_type i) const;
+			GLM_FUNC_DECL col_type & operator[](size_type i);
+			GLM_FUNC_DECL col_type const & operator[](size_type i) const;
 
 			// Unary updatable operators
-			tmat3x2<T> & operator=  (tmat3x2<T> const & m);
+			GLM_FUNC_DECL tmat3x2<T> & operator=  (tmat3x2<T> const & m);
 			template <typename U> 
-			tmat3x2<T> & operator=  (tmat3x2<U> const & m);
+			GLM_FUNC_DECL tmat3x2<T> & operator=  (tmat3x2<U> const & m);
 			template <typename U> 
-			tmat3x2<T> & operator+= (U const & s);
+			GLM_FUNC_DECL tmat3x2<T> & operator+= (U const & s);
 			template <typename U> 
-			tmat3x2<T> & operator+= (tmat3x2<U> const & m);
+			GLM_FUNC_DECL tmat3x2<T> & operator+= (tmat3x2<U> const & m);
 			template <typename U> 
-			tmat3x2<T> & operator-= (U const & s);
+			GLM_FUNC_DECL tmat3x2<T> & operator-= (U const & s);
 			template <typename U> 
-			tmat3x2<T> & operator-= (tmat3x2<U> const & m);
+			GLM_FUNC_DECL tmat3x2<T> & operator-= (tmat3x2<U> const & m);
 			template <typename U> 
-			tmat3x2<T> & operator*= (U const & s);
+			GLM_FUNC_DECL tmat3x2<T> & operator*= (U const & s);
 			template <typename U> 
-			tmat3x2<T> & operator*= (tmat3x2<U> const & m);
+			GLM_FUNC_DECL tmat3x2<T> & operator*= (tmat3x2<U> const & m);
 			template <typename U> 
-			tmat3x2<T> & operator/= (U const & s);
+			GLM_FUNC_DECL tmat3x2<T> & operator/= (U const & s);
 
-			tmat3x2<T> & operator++ ();
-			tmat3x2<T> & operator-- ();
+			GLM_FUNC_DECL tmat3x2<T> & operator++ ();
+			GLM_FUNC_DECL tmat3x2<T> & operator-- ();
 		};
 
 		// Binary operators
diff --git a/glm/core/type_mat3x3.hpp b/glm/core/type_mat3x3.hpp
index e5edfaff..bf18c167 100644
--- a/glm/core/type_mat3x3.hpp
+++ b/glm/core/type_mat3x3.hpp
@@ -45,15 +45,15 @@ namespace glm
 			typedef std::size_t size_type;
 			typedef tvec3<T> col_type;
 			typedef tvec3<T> row_type;
-			static size_type col_size();
-			static size_type row_size();
+			static GLM_FUNC_DECL size_type col_size();
+			static GLM_FUNC_DECL size_type row_size();
 
 			typedef tmat3x3<T> type;
 			typedef tmat3x3<T> transpose_type;
 
 		public:
 			// Implementation detail
-			tmat3x3<T> _inverse() const;
+			GLM_FUNC_DECL tmat3x3<T> _inverse() const;
 
 		private:
 			// Data
@@ -61,61 +61,61 @@ namespace glm
 
 		public:
 			// Constructors
-			tmat3x3();
-			tmat3x3(tmat3x3 const & m);
+			GLM_FUNC_DECL tmat3x3();
+			GLM_FUNC_DECL tmat3x3(tmat3x3 const & m);
 
-			explicit tmat3x3(
+			GLM_FUNC_DECL explicit tmat3x3(
 				ctor Null);
-			explicit tmat3x3(
+			GLM_FUNC_DECL explicit tmat3x3(
 				value_type const & s);
-			explicit tmat3x3(
+			GLM_FUNC_DECL explicit tmat3x3(
 				value_type const & x0, value_type const & y0, value_type const & z0,
 				value_type const & x1, value_type const & y1, value_type const & z1,
 				value_type const & x2, value_type const & y2, value_type const & z2);
-			explicit tmat3x3(
+			GLM_FUNC_DECL explicit tmat3x3(
 				col_type const & v0, 
 				col_type const & v1,
 				col_type const & v2);
 
 			// Conversions
 			template <typename U> 
-			explicit tmat3x3(tmat3x3<U> const & m);
+			GLM_FUNC_DECL explicit tmat3x3(tmat3x3<U> const & m);
 
-			explicit tmat3x3(tmat2x2<T> const & x);
-			explicit tmat3x3(tmat4x4<T> const & x);
-			explicit tmat3x3(tmat2x3<T> const & x);
-			explicit tmat3x3(tmat3x2<T> const & x);
-			explicit tmat3x3(tmat2x4<T> const & x);
-			explicit tmat3x3(tmat4x2<T> const & x);
-			explicit tmat3x3(tmat3x4<T> const & x);
-			explicit tmat3x3(tmat4x3<T> const & x);
+			GLM_FUNC_DECL explicit tmat3x3(tmat2x2<T> const & x);
+			GLM_FUNC_DECL explicit tmat3x3(tmat4x4<T> const & x);
+			GLM_FUNC_DECL explicit tmat3x3(tmat2x3<T> const & x);
+			GLM_FUNC_DECL explicit tmat3x3(tmat3x2<T> const & x);
+			GLM_FUNC_DECL explicit tmat3x3(tmat2x4<T> const & x);
+			GLM_FUNC_DECL explicit tmat3x3(tmat4x2<T> const & x);
+			GLM_FUNC_DECL explicit tmat3x3(tmat3x4<T> const & x);
+			GLM_FUNC_DECL explicit tmat3x3(tmat4x3<T> const & x);
 
 			// Accesses
-			col_type & operator[](size_type i);
-			col_type const & operator[](size_type i) const;
+			GLM_FUNC_DECL col_type & operator[](size_type i);
+			GLM_FUNC_DECL col_type const & operator[](size_type i) const;
 
 			// Unary updatable operators
-			tmat3x3<T>& operator=  (tmat3x3<T> const & m);
+			GLM_FUNC_DECL tmat3x3<T>& operator=  (tmat3x3<T> const & m);
 			template <typename U> 
-			tmat3x3<T>& operator=  (tmat3x3<U> const & m);
+			GLM_FUNC_DECL tmat3x3<T>& operator=  (tmat3x3<U> const & m);
 			template <typename U> 
-			tmat3x3<T>& operator+= (U const & s);
+			GLM_FUNC_DECL tmat3x3<T>& operator+= (U const & s);
 			template <typename U> 
-			tmat3x3<T>& operator+= (tmat3x3<U> const & m);
+			GLM_FUNC_DECL tmat3x3<T>& operator+= (tmat3x3<U> const & m);
 			template <typename U> 
-			tmat3x3<T>& operator-= (U const & s);
+			GLM_FUNC_DECL tmat3x3<T>& operator-= (U const & s);
 			template <typename U> 
-			tmat3x3<T>& operator-= (tmat3x3<U> const & m);
+			GLM_FUNC_DECL tmat3x3<T>& operator-= (tmat3x3<U> const & m);
 			template <typename U> 
-			tmat3x3<T>& operator*= (U const & s);
+			GLM_FUNC_DECL tmat3x3<T>& operator*= (U const & s);
 			template <typename U> 
-			tmat3x3<T>& operator*= (tmat3x3<U> const & m);
+			GLM_FUNC_DECL tmat3x3<T>& operator*= (tmat3x3<U> const & m);
 			template <typename U> 
-			tmat3x3<T>& operator/= (U const & s);
+			GLM_FUNC_DECL tmat3x3<T>& operator/= (U const & s);
 			template <typename U> 
-			tmat3x3<T>& operator/= (tmat3x3<U> const & m);
-			tmat3x3<T>& operator++ ();
-			tmat3x3<T>& operator-- ();
+			GLM_FUNC_DECL tmat3x3<T>& operator/= (tmat3x3<U> const & m);
+			GLM_FUNC_DECL tmat3x3<T>& operator++ ();
+			GLM_FUNC_DECL tmat3x3<T>& operator-- ();
 		};
 
 		// Binary operators
diff --git a/glm/core/type_mat3x4.hpp b/glm/core/type_mat3x4.hpp
index 6f68b4cd..1f84ec7b 100644
--- a/glm/core/type_mat3x4.hpp
+++ b/glm/core/type_mat3x4.hpp
@@ -45,8 +45,8 @@ namespace glm
 			typedef std::size_t size_type;
 			typedef tvec4<T> col_type;
 			typedef tvec3<T> row_type;
-			static size_type col_size();
-			static size_type row_size();
+			static GLM_FUNC_DECL size_type col_size();
+			static GLM_FUNC_DECL size_type row_size();
 
 			typedef tmat3x4<T> type;
 			typedef tmat4x3<T> transpose_type;
@@ -57,60 +57,60 @@ namespace glm
 
 		public:
 			// Constructors
-			tmat3x4();
-			tmat3x4(tmat3x4 const & m);
+			GLM_FUNC_DECL tmat3x4();
+			GLM_FUNC_DECL tmat3x4(tmat3x4 const & m);
 
-			explicit tmat3x4(
+			GLM_FUNC_DECL explicit tmat3x4(
 				ctor Null);
-			explicit tmat3x4(
+			GLM_FUNC_DECL explicit tmat3x4(
 				value_type const & s);
-			explicit tmat3x4(
+			GLM_FUNC_DECL explicit tmat3x4(
 				value_type const & x0, value_type const & y0, value_type const & z0, value_type const & w0,
 				value_type const & x1, value_type const & y1, value_type const & z1, value_type const & w1,
 				value_type const & x2, value_type const & y2, value_type const & z2, value_type const & w2);
-			explicit tmat3x4(
+			GLM_FUNC_DECL explicit tmat3x4(
 				col_type const & v0, 
 				col_type const & v1,
 				col_type const & v2);
 
 			// Conversion
 			template <typename U> 
-			explicit tmat3x4(tmat3x4<U> const & m);
+			GLM_FUNC_DECL explicit tmat3x4(tmat3x4<U> const & m);
 
-			explicit tmat3x4(tmat2x2<T> const & x);
-			explicit tmat3x4(tmat3x3<T> const & x);
-			explicit tmat3x4(tmat4x4<T> const & x);
-			explicit tmat3x4(tmat2x3<T> const & x);
-			explicit tmat3x4(tmat3x2<T> const & x);
-			explicit tmat3x4(tmat2x4<T> const & x);
-			explicit tmat3x4(tmat4x2<T> const & x);
-			explicit tmat3x4(tmat4x3<T> const & x);
+			GLM_FUNC_DECL explicit tmat3x4(tmat2x2<T> const & x);
+			GLM_FUNC_DECL explicit tmat3x4(tmat3x3<T> const & x);
+			GLM_FUNC_DECL explicit tmat3x4(tmat4x4<T> const & x);
+			GLM_FUNC_DECL explicit tmat3x4(tmat2x3<T> const & x);
+			GLM_FUNC_DECL explicit tmat3x4(tmat3x2<T> const & x);
+			GLM_FUNC_DECL explicit tmat3x4(tmat2x4<T> const & x);
+			GLM_FUNC_DECL explicit tmat3x4(tmat4x2<T> const & x);
+			GLM_FUNC_DECL explicit tmat3x4(tmat4x3<T> const & x);
 
 			// Accesses
 			col_type & operator[](size_type i);
 			col_type const & operator[](size_type i) const;
 
 			// Unary updatable operators
-			tmat3x4<T> & operator=  (tmat3x4<T> const & m);
+			GLM_FUNC_DECL tmat3x4<T> & operator=  (tmat3x4<T> const & m);
 			template <typename U> 
-			tmat3x4<T> & operator=  (tmat3x4<U> const & m);
+			GLM_FUNC_DECL tmat3x4<T> & operator=  (tmat3x4<U> const & m);
 			template <typename U> 
-			tmat3x4<T> & operator+= (U const & s);
+			GLM_FUNC_DECL tmat3x4<T> & operator+= (U const & s);
 			template <typename U> 
-			tmat3x4<T> & operator+= (tmat3x4<U> const & m);
+			GLM_FUNC_DECL tmat3x4<T> & operator+= (tmat3x4<U> const & m);
 			template <typename U> 
-			tmat3x4<T> & operator-= (U const & s);
+			GLM_FUNC_DECL tmat3x4<T> & operator-= (U const & s);
 			template <typename U> 
-			tmat3x4<T> & operator-= (tmat3x4<U> const & m);
+			GLM_FUNC_DECL tmat3x4<T> & operator-= (tmat3x4<U> const & m);
 			template <typename U> 
-			tmat3x4<T> & operator*= (U const & s);
+			GLM_FUNC_DECL tmat3x4<T> & operator*= (U const & s);
 			template <typename U> 
-			tmat3x4<T> & operator*= (tmat3x4<U> const & m);
+			GLM_FUNC_DECL tmat3x4<T> & operator*= (tmat3x4<U> const & m);
 			template <typename U> 
-			tmat3x4<T> & operator/= (U const & s);
+			GLM_FUNC_DECL tmat3x4<T> & operator/= (U const & s);
 
-			tmat3x4<T> & operator++ ();
-			tmat3x4<T> & operator-- ();
+			GLM_FUNC_DECL tmat3x4<T> & operator++ ();
+			GLM_FUNC_DECL tmat3x4<T> & operator-- ();
 		};
 
 		// Binary operators
diff --git a/glm/core/type_mat4x2.hpp b/glm/core/type_mat4x2.hpp
index 3d90e3ac..3354ce8e 100644
--- a/glm/core/type_mat4x2.hpp
+++ b/glm/core/type_mat4x2.hpp
@@ -45,8 +45,8 @@ namespace glm
 			typedef std::size_t size_type;
 			typedef tvec2<T> col_type;
 			typedef tvec4<T> row_type;
-			static size_type col_size();
-			static size_type row_size();
+			static GLM_FUNC_DECL size_type col_size();
+			static GLM_FUNC_DECL size_type row_size();
 
 			typedef tmat4x2<T> type;
 			typedef tmat2x4<T> transpose_type;
@@ -57,19 +57,19 @@ namespace glm
 
 		public:
 			// Constructors
-			tmat4x2();
-			tmat4x2(tmat4x2 const & m);
+			GLM_FUNC_DECL tmat4x2();
+			GLM_FUNC_DECL tmat4x2(tmat4x2 const & m);
 
-			explicit tmat4x2(
+			GLM_FUNC_DECL explicit tmat4x2(
 				ctor Null);
-			explicit tmat4x2(
+			GLM_FUNC_DECL explicit tmat4x2(
 				value_type const & x);
-			explicit tmat4x2(
+			GLM_FUNC_DECL explicit tmat4x2(
 				value_type const & x0, value_type const & y0,
 				value_type const & x1, value_type const & y1,
 				value_type const & x2, value_type const & y2,
 				value_type const & x3, value_type const & y3);
-			explicit tmat4x2(
+			GLM_FUNC_DECL explicit tmat4x2(
 				col_type const & v0, 
 				col_type const & v1,
 				col_type const & v2,
@@ -77,42 +77,42 @@ namespace glm
 
 			// Conversions
 			template <typename U> 
-			explicit tmat4x2(tmat4x2<U> const & m);
+			GLM_FUNC_DECL explicit tmat4x2(tmat4x2<U> const & m);
 			
-			explicit tmat4x2(tmat2x2<T> const & x);
-			explicit tmat4x2(tmat3x3<T> const & x);
-			explicit tmat4x2(tmat4x4<T> const & x);
-			explicit tmat4x2(tmat2x3<T> const & x);
-			explicit tmat4x2(tmat3x2<T> const & x);
-			explicit tmat4x2(tmat2x4<T> const & x);
-			explicit tmat4x2(tmat4x3<T> const & x);
-			explicit tmat4x2(tmat3x4<T> const & x);
+			GLM_FUNC_DECL explicit tmat4x2(tmat2x2<T> const & x);
+			GLM_FUNC_DECL explicit tmat4x2(tmat3x3<T> const & x);
+			GLM_FUNC_DECL explicit tmat4x2(tmat4x4<T> const & x);
+			GLM_FUNC_DECL explicit tmat4x2(tmat2x3<T> const & x);
+			GLM_FUNC_DECL explicit tmat4x2(tmat3x2<T> const & x);
+			GLM_FUNC_DECL explicit tmat4x2(tmat2x4<T> const & x);
+			GLM_FUNC_DECL explicit tmat4x2(tmat4x3<T> const & x);
+			GLM_FUNC_DECL explicit tmat4x2(tmat3x4<T> const & x);
 
 			// Accesses
-			col_type & operator[](size_type i);
-			col_type const & operator[](size_type i) const;
+			GLM_FUNC_DECL col_type & operator[](size_type i);
+			GLM_FUNC_DECL col_type const & operator[](size_type i) const;
 
 			// Unary updatable operators
-			tmat4x2<T>& operator=  (tmat4x2<T> const & m);
+			GLM_FUNC_DECL tmat4x2<T>& operator=  (tmat4x2<T> const & m);
 			template <typename U> 
-			tmat4x2<T>& operator=  (tmat4x2<U> const & m);
+			GLM_FUNC_DECL tmat4x2<T>& operator=  (tmat4x2<U> const & m);
 			template <typename U> 
-			tmat4x2<T>& operator+= (U const & s);
+			GLM_FUNC_DECL tmat4x2<T>& operator+= (U const & s);
 			template <typename U> 
-			tmat4x2<T>& operator+= (tmat4x2<U> const & m);
+			GLM_FUNC_DECL tmat4x2<T>& operator+= (tmat4x2<U> const & m);
 			template <typename U> 
-			tmat4x2<T>& operator-= (U const & s);
+			GLM_FUNC_DECL tmat4x2<T>& operator-= (U const & s);
 			template <typename U> 
-			tmat4x2<T>& operator-= (tmat4x2<U> const & m);
+			GLM_FUNC_DECL tmat4x2<T>& operator-= (tmat4x2<U> const & m);
 			template <typename U> 
-			tmat4x2<T>& operator*= (U const & s);
+			GLM_FUNC_DECL tmat4x2<T>& operator*= (U const & s);
 			template <typename U> 
-			tmat4x2<T>& operator*= (tmat4x2<U> const & m);
+			GLM_FUNC_DECL tmat4x2<T>& operator*= (tmat4x2<U> const & m);
 			template <typename U> 
-			tmat4x2<T>& operator/= (U const & s);
+			GLM_FUNC_DECL tmat4x2<T>& operator/= (U const & s);
 
-			tmat4x2<T>& operator++ ();
-			tmat4x2<T>& operator-- ();
+			GLM_FUNC_DECL tmat4x2<T>& operator++ ();
+			GLM_FUNC_DECL tmat4x2<T>& operator-- ();
 		};
 
 		// Binary operators
diff --git a/glm/core/type_mat4x3.hpp b/glm/core/type_mat4x3.hpp
index d9a311ad..b15a3c30 100644
--- a/glm/core/type_mat4x3.hpp
+++ b/glm/core/type_mat4x3.hpp
@@ -45,8 +45,8 @@ namespace glm
 			typedef std::size_t size_type;
 			typedef tvec3<T> col_type;
 			typedef tvec4<T> row_type;
-			static size_type col_size();
-			static size_type row_size();
+			static GLM_FUNC_DECL size_type col_size();
+			static GLM_FUNC_DECL size_type row_size();
 
 			typedef tmat4x3<T> type;
 			typedef tmat3x4<T> transpose_type;
@@ -57,19 +57,19 @@ namespace glm
 
 		public:
 			// Constructors
-			tmat4x3();
-			tmat4x3(tmat4x3 const & m);
+			GLM_FUNC_DECL tmat4x3();
+			GLM_FUNC_DECL tmat4x3(tmat4x3 const & m);
 
-			explicit tmat4x3(
+			GLM_FUNC_DECL explicit tmat4x3(
 				ctor Null);
-			explicit tmat4x3(
+			GLM_FUNC_DECL explicit tmat4x3(
 				value_type const & x);
-			explicit tmat4x3(
+			GLM_FUNC_DECL explicit tmat4x3(
 				value_type const & x0, value_type const & y0, value_type const & z0,
 				value_type const & x1, value_type const & y1, value_type const & z1,
 				value_type const & x2, value_type const & y2, value_type const & z2,
 				value_type const & x3, value_type const & y3, value_type const & z3);
-			explicit tmat4x3(
+			GLM_FUNC_DECL explicit tmat4x3(
 				col_type const & v0, 
 				col_type const & v1,
 				col_type const & v2,
@@ -77,42 +77,42 @@ namespace glm
 
 			// Conversion
 			template <typename U> 
-			explicit tmat4x3(tmat4x3<U> const & m);
+			GLM_FUNC_DECL explicit tmat4x3(tmat4x3<U> const & m);
 			
-			explicit tmat4x3(tmat2x2<T> const & x);
-			explicit tmat4x3(tmat3x3<T> const & x);
-			explicit tmat4x3(tmat4x4<T> const & x);
-			explicit tmat4x3(tmat2x3<T> const & x);
-			explicit tmat4x3(tmat3x2<T> const & x);
-			explicit tmat4x3(tmat2x4<T> const & x);
-			explicit tmat4x3(tmat4x2<T> const & x);
-			explicit tmat4x3(tmat3x4<T> const & x);
+			GLM_FUNC_DECL explicit tmat4x3(tmat2x2<T> const & x);
+			GLM_FUNC_DECL explicit tmat4x3(tmat3x3<T> const & x);
+			GLM_FUNC_DECL explicit tmat4x3(tmat4x4<T> const & x);
+			GLM_FUNC_DECL explicit tmat4x3(tmat2x3<T> const & x);
+			GLM_FUNC_DECL explicit tmat4x3(tmat3x2<T> const & x);
+			GLM_FUNC_DECL explicit tmat4x3(tmat2x4<T> const & x);
+			GLM_FUNC_DECL explicit tmat4x3(tmat4x2<T> const & x);
+			GLM_FUNC_DECL explicit tmat4x3(tmat3x4<T> const & x);
 
 			// Accesses
 			col_type & operator[](size_type i);
 			col_type const & operator[](size_type i) const;
 
 			// Unary updatable operators
-			tmat4x3<T> & operator=  (tmat4x3<T> const & m);
+			GLM_FUNC_DECL tmat4x3<T> & operator=  (tmat4x3<T> const & m);
 			template <typename U> 
-			tmat4x3<T> & operator=  (tmat4x3<U> const & m);
+			GLM_FUNC_DECL tmat4x3<T> & operator=  (tmat4x3<U> const & m);
 			template <typename U> 
-			tmat4x3<T> & operator+= (U const & s);
+			GLM_FUNC_DECL tmat4x3<T> & operator+= (U const & s);
 			template <typename U> 
-			tmat4x3<T> & operator+= (tmat4x3<U> const & m);
+			GLM_FUNC_DECL tmat4x3<T> & operator+= (tmat4x3<U> const & m);
 			template <typename U> 
-			tmat4x3<T> & operator-= (U const & s);
+			GLM_FUNC_DECL tmat4x3<T> & operator-= (U const & s);
 			template <typename U> 
-			tmat4x3<T> & operator-= (tmat4x3<U> const & m);
+			GLM_FUNC_DECL tmat4x3<T> & operator-= (tmat4x3<U> const & m);
 			template <typename U> 
-			tmat4x3<T> & operator*= (U const & s);
+			GLM_FUNC_DECL tmat4x3<T> & operator*= (U const & s);
 			template <typename U> 
-			tmat4x3<T> & operator*= (tmat4x3<U> const & m);
+			GLM_FUNC_DECL tmat4x3<T> & operator*= (tmat4x3<U> const & m);
 			template <typename U> 
-			tmat4x3<T> & operator/= (U const & s);
+			GLM_FUNC_DECL tmat4x3<T> & operator/= (U const & s);
 
-			tmat4x3<T> & operator++ ();
-			tmat4x3<T> & operator-- ();
+			GLM_FUNC_DECL tmat4x3<T> & operator++ ();
+			GLM_FUNC_DECL tmat4x3<T> & operator-- ();
 		};
 
 		// Binary operators
diff --git a/glm/core/type_mat4x4.hpp b/glm/core/type_mat4x4.hpp
index 05325a1e..6aa1f68a 100644
--- a/glm/core/type_mat4x4.hpp
+++ b/glm/core/type_mat4x4.hpp
@@ -45,15 +45,15 @@ namespace glm
 			typedef std::size_t size_type;
 			typedef tvec4<T> col_type;
 			typedef tvec4<T> row_type;
-			static size_type col_size();
-			static size_type row_size();
+			static GLM_FUNC_DECL size_type col_size();
+			static GLM_FUNC_DECL size_type row_size();
 
 			typedef tmat4x4<T> type;
 			typedef tmat4x4<T> transpose_type;
 
 		public:
 			// Implementation detail
-			tmat4x4<T> _inverse() const;
+			GLM_FUNC_DECL tmat4x4<T> _inverse() const;
 
 		private:
 			// Data 
@@ -61,19 +61,19 @@ namespace glm
 
 		public:
 			// Constructors
-			tmat4x4();
-			tmat4x4(tmat4x4 const & m);
+			GLM_FUNC_DECL tmat4x4();
+			GLM_FUNC_DECL tmat4x4(tmat4x4 const & m);
 
-			explicit tmat4x4(
+			GLM_FUNC_DECL explicit tmat4x4(
 				ctor Null);
-			explicit tmat4x4(
+			GLM_FUNC_DECL explicit tmat4x4(
 				value_type const & x);
-			explicit tmat4x4(
+			GLM_FUNC_DECL explicit tmat4x4(
 				value_type const & x0, value_type const & y0, value_type const & z0, value_type const & w0,
 				value_type const & x1, value_type const & y1, value_type const & z1, value_type const & w1,
 				value_type const & x2, value_type const & y2, value_type const & z2, value_type const & w2,
 				value_type const & x3, value_type const & y3, value_type const & z3, value_type const & w3);
-			explicit tmat4x4(
+			GLM_FUNC_DECL explicit tmat4x4(
 				col_type const & v0, 
 				col_type const & v1,
 				col_type const & v2,
@@ -81,43 +81,43 @@ namespace glm
 
 			// Conversions
 			template <typename U> 
-			explicit tmat4x4(tmat4x4<U> const & m);
+			GLM_FUNC_DECL explicit tmat4x4(tmat4x4<U> const & m);
 
-			explicit tmat4x4(tmat2x2<T> const & x);
-			explicit tmat4x4(tmat3x3<T> const & x);
-			explicit tmat4x4(tmat2x3<T> const & x);
-			explicit tmat4x4(tmat3x2<T> const & x);
-			explicit tmat4x4(tmat2x4<T> const & x);
-			explicit tmat4x4(tmat4x2<T> const & x);
-			explicit tmat4x4(tmat3x4<T> const & x);
-			explicit tmat4x4(tmat4x3<T> const & x);
+			GLM_FUNC_DECL explicit tmat4x4(tmat2x2<T> const & x);
+			GLM_FUNC_DECL explicit tmat4x4(tmat3x3<T> const & x);
+			GLM_FUNC_DECL explicit tmat4x4(tmat2x3<T> const & x);
+			GLM_FUNC_DECL explicit tmat4x4(tmat3x2<T> const & x);
+			GLM_FUNC_DECL explicit tmat4x4(tmat2x4<T> const & x);
+			GLM_FUNC_DECL explicit tmat4x4(tmat4x2<T> const & x);
+			GLM_FUNC_DECL explicit tmat4x4(tmat3x4<T> const & x);
+			GLM_FUNC_DECL explicit tmat4x4(tmat4x3<T> const & x);
 
 			// Accesses
-			col_type & operator[](size_type i);
-			col_type const & operator[](size_type i) const;
+			GLM_FUNC_DECL col_type & operator[](size_type i);
+			GLM_FUNC_DECL col_type const & operator[](size_type i) const;
 
 			// Unary updatable operators
-			tmat4x4<T> & operator=  (tmat4x4<T> const & m);
+			GLM_FUNC_DECL tmat4x4<T> & operator=  (tmat4x4<T> const & m);
 			template <typename U>
-			tmat4x4<T> & operator=  (tmat4x4<U> const & m);
+			GLM_FUNC_DECL tmat4x4<T> & operator=  (tmat4x4<U> const & m);
 			template <typename U>
-			tmat4x4<T> & operator+= (U const & s);
+			GLM_FUNC_DECL tmat4x4<T> & operator+= (U const & s);
 			template <typename U>
-			tmat4x4<T> & operator+= (tmat4x4<U> const & m);
+			GLM_FUNC_DECL tmat4x4<T> & operator+= (tmat4x4<U> const & m);
 			template <typename U>
-			tmat4x4<T> & operator-= (U const & s);
+			GLM_FUNC_DECL tmat4x4<T> & operator-= (U const & s);
 			template <typename U>
-			tmat4x4<T> & operator-= (tmat4x4<U> const & m);
+			GLM_FUNC_DECL tmat4x4<T> & operator-= (tmat4x4<U> const & m);
 			template <typename U>
-			tmat4x4<T> & operator*= (U const & s);
+			GLM_FUNC_DECL tmat4x4<T> & operator*= (U const & s);
 			template <typename U>
-			tmat4x4<T> & operator*= (tmat4x4<U> const & m);
+			GLM_FUNC_DECL tmat4x4<T> & operator*= (tmat4x4<U> const & m);
 			template <typename U>
-			tmat4x4<T> & operator/= (U const & s);
+			GLM_FUNC_DECL tmat4x4<T> & operator/= (U const & s);
 			template <typename U>
-			tmat4x4<T> & operator/= (tmat4x4<U> const & m);
-			tmat4x4<T> & operator++ ();
-			tmat4x4<T> & operator-- ();
+			GLM_FUNC_DECL tmat4x4<T> & operator/= (tmat4x4<U> const & m);
+			GLM_FUNC_DECL tmat4x4<T> & operator++ ();
+			GLM_FUNC_DECL tmat4x4<T> & operator-- ();
 		};
 
 		// Binary operators
diff --git a/glm/core/type_vec1.hpp b/glm/core/type_vec1.hpp
index 2b3ad663..5dcbca88 100644
--- a/glm/core/type_vec1.hpp
+++ b/glm/core/type_vec1.hpp
@@ -41,7 +41,7 @@ namespace glm
 
 			typedef T value_type;
 			typedef std::size_t size_type;
-			static size_type value_size();
+			static GLM_FUNC_DECL size_type value_size();
 
 			typedef tvec1<T> type;
 			typedef tvec1<bool> bool_type;
@@ -58,99 +58,99 @@ namespace glm
 			//////////////////////////////////////
 			// Accesses
 
-			value_type & operator[](size_type i);
-			value_type const & operator[](size_type i) const;
+			GLM_FUNC_DECL value_type & operator[](size_type i);
+			GLM_FUNC_DECL value_type const & operator[](size_type i) const;
 
 			//////////////////////////////////////
 			// Implicit basic constructors
 
-			tvec1();
-			tvec1(tvec1<T> const & v);
+			GLM_FUNC_DECL tvec1();
+			GLM_FUNC_DECL tvec1(tvec1<T> const & v);
 
 			//////////////////////////////////////
 			// Explicit basic constructors
 
-			explicit tvec1(
+			GLM_FUNC_DECL explicit tvec1(
 				ctor);
-			explicit tvec1(
+			GLM_FUNC_DECL explicit tvec1(
 				value_type const & s);
 
 			//////////////////////////////////////
 			// Swizzle constructors
 
-			tvec1(tref1<T> const & r);
+			GLM_FUNC_DECL tvec1(tref1<T> const & r);
 
 			//////////////////////////////////////
 			// Convertion scalar constructors
 
 			//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 			template <typename U> 
-			explicit tvec1(U const & s);
+			GLM_FUNC_DECL explicit tvec1(U const & s);
 
 			//////////////////////////////////////
 			// Convertion vector constructors
 
 			//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 			template <typename U> 
-			explicit tvec1(tvec2<U> const & v);
+			GLM_FUNC_DECL explicit tvec1(tvec2<U> const & v);
 			//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 			template <typename U> 
-			explicit tvec1(tvec3<U> const & v);
+			GLM_FUNC_DECL explicit tvec1(tvec3<U> const & v);
 			//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 			template <typename U> 
-			explicit tvec1(tvec4<U> const & v);
+			GLM_FUNC_DECL explicit tvec1(tvec4<U> const & v);
 
 			//////////////////////////////////////
 			// Unary arithmetic operators
 
-			tvec1<T> & operator= (tvec1<T> const & v);
+			GLM_FUNC_DECL tvec1<T> & operator= (tvec1<T> const & v);
 
-			tvec1<T> & operator+=(value_type const & s);
-			tvec1<T> & operator+=(tvec1<T> const & v);
-			tvec1<T> & operator-=(value_type const & s);
-			tvec1<T> & operator-=(tvec1<T> const & v);
-			tvec1<T> & operator*=(value_type const & s);
-			tvec1<T> & operator*=(tvec1<T> const & v);
-			tvec1<T> & operator/=(value_type const & s);
-			tvec1<T> & operator/=(tvec1<T> const & v);
-			tvec1<T> & operator++();
-			tvec1<T> & operator--();
+			GLM_FUNC_DECL tvec1<T> & operator+=(value_type const & s);
+			GLM_FUNC_DECL tvec1<T> & operator+=(tvec1<T> const & v);
+			GLM_FUNC_DECL tvec1<T> & operator-=(value_type const & s);
+			GLM_FUNC_DECL tvec1<T> & operator-=(tvec1<T> const & v);
+			GLM_FUNC_DECL tvec1<T> & operator*=(value_type const & s);
+			GLM_FUNC_DECL tvec1<T> & operator*=(tvec1<T> const & v);
+			GLM_FUNC_DECL tvec1<T> & operator/=(value_type const & s);
+			GLM_FUNC_DECL tvec1<T> & operator/=(tvec1<T> const & v);
+			GLM_FUNC_DECL tvec1<T> & operator++();
+			GLM_FUNC_DECL tvec1<T> & operator--();
 
 			//////////////////////////////////////
 			// Unary bit operators
 
-			tvec1<T> & operator%=(value_type const & s);
-			tvec1<T> & operator%=(tvec1<T> const & v);
-			tvec1<T> & operator&=(value_type const & s);
-			tvec1<T> & operator&=(tvec1<T> const & v);
-			tvec1<T> & operator|=(value_type const & s);
-			tvec1<T> & operator|=(tvec1<T> const & v);
-			tvec1<T> & operator^=(value_type const & s);
-			tvec1<T> & operator^=(tvec1<T> const & v);
-			tvec1<T> & operator<<=(value_type const & s);
-			tvec1<T> & operator<<=(tvec1<T> const & v);
-			tvec1<T> & operator>>=(value_type const & s);
-			tvec1<T> & operator>>=(tvec1<T> const & v);
+			GLM_FUNC_DECL tvec1<T> & operator%=(value_type const & s);
+			GLM_FUNC_DECL tvec1<T> & operator%=(tvec1<T> const & v);
+			GLM_FUNC_DECL tvec1<T> & operator&=(value_type const & s);
+			GLM_FUNC_DECL tvec1<T> & operator&=(tvec1<T> const & v);
+			GLM_FUNC_DECL tvec1<T> & operator|=(value_type const & s);
+			GLM_FUNC_DECL tvec1<T> & operator|=(tvec1<T> const & v);
+			GLM_FUNC_DECL tvec1<T> & operator^=(value_type const & s);
+			GLM_FUNC_DECL tvec1<T> & operator^=(tvec1<T> const & v);
+			GLM_FUNC_DECL tvec1<T> & operator<<=(value_type const & s);
+			GLM_FUNC_DECL tvec1<T> & operator<<=(tvec1<T> const & v);
+			GLM_FUNC_DECL tvec1<T> & operator>>=(value_type const & s);
+			GLM_FUNC_DECL tvec1<T> & operator>>=(tvec1<T> const & v);
 
 			//////////////////////////////////////
 			// Swizzle operators
 
-			value_type swizzle(comp X) const;
-			tvec2<T> swizzle(comp X, comp Y) const;
-			tvec3<T> swizzle(comp X, comp Y, comp Z) const;
-			tvec4<T> swizzle(comp X, comp Y, comp Z, comp W) const;
-			tref1<T> swizzle(comp X);
+			GLM_FUNC_DECL value_type swizzle(comp X) const;
+			GLM_FUNC_DECL tvec2<T> swizzle(comp X, comp Y) const;
+			GLM_FUNC_DECL tvec3<T> swizzle(comp X, comp Y, comp Z) const;
+			GLM_FUNC_DECL tvec4<T> swizzle(comp X, comp Y, comp Z, comp W) const;
+			GLM_FUNC_DECL tref1<T> swizzle(comp X);
 		};
 
 		template <typename T>
 		struct tref1
 		{
-			tref1(T & x);
-			tref1(tref1<T> const & r);
-			tref1(tvec1<T> const & v);
+			GLM_FUNC_DECL tref1(T & x);
+			GLM_FUNC_DECL tref1(tref1<T> const & r);
+			GLM_FUNC_DECL tref1(tvec1<T> const & v);
 
-			tref1<T> & operator= (tref1<T> const & r);
-			tref1<T> & operator= (tvec1<T> const & v);
+			GLM_FUNC_DECL tref1<T> & operator= (tref1<T> const & r);
+			GLM_FUNC_DECL tref1<T> & operator= (tvec1<T> const & v);
 
 			T& x;
 		};
diff --git a/glm/core/type_vec2.hpp b/glm/core/type_vec2.hpp
index 3e212c88..47e384de 100644
--- a/glm/core/type_vec2.hpp
+++ b/glm/core/type_vec2.hpp
@@ -41,7 +41,7 @@ namespace glm
 
 			typedef T value_type;
 			typedef std::size_t size_type;
-			static size_type value_size();
+			static GLM_FUNC_DECL size_type value_size();
 
 			typedef tvec2<T> type;
 			typedef tvec2<bool> bool_type;
@@ -66,23 +66,23 @@ namespace glm
 			//////////////////////////////////////
 			// Accesses
 
-			value_type & operator[](size_type i);
-			value_type const & operator[](size_type i) const;
+			GLM_FUNC_DECL value_type & operator[](size_type i);
+			GLM_FUNC_DECL value_type const & operator[](size_type i) const;
 
 			//////////////////////////////////////
 			// Implicit basic constructors
 
-			tvec2();
-			tvec2(tvec2<T> const & v);
+			GLM_FUNC_DECL tvec2();
+			GLM_FUNC_DECL tvec2(tvec2<T> const & v);
 
 			//////////////////////////////////////
 			// Explicit basic constructors
 
-			explicit tvec2(
+			GLM_FUNC_DECL explicit tvec2(
 				ctor);
-			explicit tvec2(
+			GLM_FUNC_DECL explicit tvec2(
 				value_type const & s);
-			explicit tvec2(
+			GLM_FUNC_DECL explicit tvec2(
 				value_type const & s1, 
 				value_type const & s2);
 
@@ -96,11 +96,11 @@ namespace glm
 
 			//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 			template <typename U> 
-			explicit tvec2(
+			GLM_FUNC_DECL explicit tvec2(
 				U const & x);
 			//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 			template <typename U, typename V> 
-			explicit tvec2(
+			GLM_FUNC_DECL explicit tvec2(
 				U const & x, 
 				V const & y);
 
@@ -109,87 +109,87 @@ namespace glm
 
 			//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 			template <typename U> 
-			explicit tvec2(tvec2<U> const & v);
+			GLM_FUNC_DECL explicit tvec2(tvec2<U> const & v);
 			//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 			template <typename U> 
-			explicit tvec2(tvec3<U> const & v);
+			GLM_FUNC_DECL explicit tvec2(tvec3<U> const & v);
 			//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 			template <typename U> 
-			explicit tvec2(tvec4<U> const & v);
+			GLM_FUNC_DECL explicit tvec2(tvec4<U> const & v);
 
 			//////////////////////////////////////
 			// Unary arithmetic operators
 
-			tvec2<T> & operator= (tvec2<T> const & v);
+			GLM_FUNC_DECL tvec2<T> & operator= (tvec2<T> const & v);
 			template <typename U> 
-			tvec2<T> & operator= (tvec2<U> const & v);
+			GLM_FUNC_DECL tvec2<T> & operator= (tvec2<U> const & v);
 
 			template <typename U> 
-			tvec2<T> & operator+=(U const & s);
+			GLM_FUNC_DECL tvec2<T> & operator+=(U const & s);
 			template <typename U> 
-			tvec2<T> & operator+=(tvec2<U> const & v);
+			GLM_FUNC_DECL tvec2<T> & operator+=(tvec2<U> const & v);
 			template <typename U> 
-			tvec2<T> & operator-=(U const & s);
+			GLM_FUNC_DECL tvec2<T> & operator-=(U const & s);
 			template <typename U> 
-			tvec2<T> & operator-=(tvec2<U> const & v);
+			GLM_FUNC_DECL tvec2<T> & operator-=(tvec2<U> const & v);
 			template <typename U> 
-			tvec2<T> & operator*=(U const & s);
+			GLM_FUNC_DECL tvec2<T> & operator*=(U const & s);
 			template <typename U> 
-			tvec2<T> & operator*=(tvec2<U> const & v);
+			GLM_FUNC_DECL tvec2<T> & operator*=(tvec2<U> const & v);
 			template <typename U> 
-			tvec2<T> & operator/=(U const & s);
+			GLM_FUNC_DECL tvec2<T> & operator/=(U const & s);
 			template <typename U> 
-			tvec2<T> & operator/=(tvec2<U> const & v);
-			tvec2<T> & operator++();
-			tvec2<T> & operator--();
+			GLM_FUNC_DECL tvec2<T> & operator/=(tvec2<U> const & v);
+			GLM_FUNC_DECL tvec2<T> & operator++();
+			GLM_FUNC_DECL tvec2<T> & operator--();
 
 			//////////////////////////////////////
 			// Unary bit operators
 
 			template <typename U> 
-			tvec2<T> & operator%= (U const & s);
+			GLM_FUNC_DECL tvec2<T> & operator%= (U const & s);
 			template <typename U> 
-			tvec2<T> & operator%= (tvec2<U> const & v);
+			GLM_FUNC_DECL tvec2<T> & operator%= (tvec2<U> const & v);
 			template <typename U> 
-			tvec2<T> & operator&= (U const & s);
+			GLM_FUNC_DECL tvec2<T> & operator&= (U const & s);
 			template <typename U> 
-			tvec2<T> & operator&= (tvec2<U> const & v);
+			GLM_FUNC_DECL tvec2<T> & operator&= (tvec2<U> const & v);
 			template <typename U> 
-			tvec2<T> & operator|= (U const & s);
+			GLM_FUNC_DECL tvec2<T> & operator|= (U const & s);
 			template <typename U> 
-			tvec2<T> & operator|= (tvec2<U> const & v);
+			GLM_FUNC_DECL tvec2<T> & operator|= (tvec2<U> const & v);
 			template <typename U> 
-			tvec2<T> & operator^= (U const & s);
+			GLM_FUNC_DECL tvec2<T> & operator^= (U const & s);
 			template <typename U> 
-			tvec2<T> & operator^= (tvec2<U> const & v);
+			GLM_FUNC_DECL tvec2<T> & operator^= (tvec2<U> const & v);
 			template <typename U> 
-			tvec2<T> & operator<<=(U const & s);
+			GLM_FUNC_DECL tvec2<T> & operator<<=(U const & s);
 			template <typename U> 
-			tvec2<T> & operator<<=(tvec2<U> const & v);
+			GLM_FUNC_DECL tvec2<T> & operator<<=(tvec2<U> const & v);
 			template <typename U> 
-			tvec2<T> & operator>>=(U const & s);
+			GLM_FUNC_DECL tvec2<T> & operator>>=(U const & s);
 			template <typename U> 
-			tvec2<T> & operator>>=(tvec2<U> const & v);
+			GLM_FUNC_DECL tvec2<T> & operator>>=(tvec2<U> const & v);
 
 			//////////////////////////////////////
 			// Swizzle operators
 
-			value_type swizzle(comp X) const;
-			tvec2<T> swizzle(comp X, comp Y) const;
-			tvec3<T> swizzle(comp X, comp Y, comp Z) const;
-			tvec4<T> swizzle(comp X, comp Y, comp Z, comp W) const;
-			tref2<T> swizzle(comp X, comp Y);
+			GLM_FUNC_DECL value_type swizzle(comp X) const;
+			GLM_FUNC_DECL tvec2<T> swizzle(comp X, comp Y) const;
+			GLM_FUNC_DECL tvec3<T> swizzle(comp X, comp Y, comp Z) const;
+			GLM_FUNC_DECL tvec4<T> swizzle(comp X, comp Y, comp Z, comp W) const;
+			GLM_FUNC_DECL tref2<T> swizzle(comp X, comp Y);
 		};
 
 		template <typename T>
 		struct tref2
 		{
-			tref2(T & x, T & y);
-			tref2(tref2<T> const & r);
-			tref2(tvec2<T> const & v);
+			GLM_FUNC_DECL tref2(T & x, T & y);
+			GLM_FUNC_DECL tref2(tref2<T> const & r);
+			GLM_FUNC_DECL tref2(tvec2<T> const & v);
 
-			tref2<T> & operator= (tref2<T> const & r);
-			tref2<T> & operator= (tvec2<T> const & v);
+			GLM_FUNC_DECL tref2<T> & operator= (tref2<T> const & r);
+			GLM_FUNC_DECL tref2<T> & operator= (tvec2<T> const & v);
 
 			T& x;
 			T& y;
diff --git a/glm/core/type_vec3.hpp b/glm/core/type_vec3.hpp
index 189950ab..7ea1cbfa 100644
--- a/glm/core/type_vec3.hpp
+++ b/glm/core/type_vec3.hpp
@@ -40,7 +40,7 @@ namespace glm
 
 			typedef T value_type;
 			typedef std::size_t size_type;
-			static size_type value_size();
+			static GLM_FUNC_DECL size_type value_size();
 
 			typedef tvec3<T> type;
 			typedef tvec3<bool> bool_type;
@@ -66,23 +66,23 @@ namespace glm
 			//////////////////////////////////////
 			// Accesses
 
-			value_type & operator[](size_type i);
-			value_type const & operator[](size_type i) const;
+			GLM_FUNC_DECL value_type & operator[](size_type i);
+			GLM_FUNC_DECL value_type const & operator[](size_type i) const;
 
 			//////////////////////////////////////
 			// Implicit basic constructors
 
-			tvec3();
-			tvec3(tvec3<T> const & v);
+			GLM_FUNC_DECL tvec3();
+			GLM_FUNC_DECL tvec3(tvec3<T> const & v);
 
 			//////////////////////////////////////
 			// Explicit basic constructors
 
-			explicit tvec3(
+			GLM_FUNC_DECL explicit tvec3(
 				ctor);
-			explicit tvec3(
+			GLM_FUNC_DECL explicit tvec3(
 				value_type const & s);
-			explicit tvec3(
+			GLM_FUNC_DECL explicit tvec3(
 				value_type const & s1, 
 				value_type const & s2, 
 				value_type const & s3);
@@ -90,18 +90,18 @@ namespace glm
 			//////////////////////////////////////
 			// Swizzle constructors
 
-			tvec3(tref3<T> const & r);
+			GLM_FUNC_DECL tvec3(tref3<T> const & r);
 
 			//////////////////////////////////////
 			// Convertion scalar constructors
 
 			//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 			template <typename U> 
-			explicit tvec3(
+			GLM_FUNC_DECL explicit tvec3(
 				U const & x);
 			//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 			template <typename U, typename V, typename W> 
-			explicit tvec3(
+			GLM_FUNC_DECL explicit tvec3(
 				U const & x, 
 				V const & y, 
 				W const & z);			
@@ -111,90 +111,90 @@ namespace glm
 
 			//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 			template <typename A, typename B> 
-			explicit tvec3(tvec2<A> const & v, B const & s);
+			GLM_FUNC_DECL explicit tvec3(tvec2<A> const & v, B const & s);
 			//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 			template <typename A, typename B> 
-			explicit tvec3(A const & s, tvec2<B> const & v);
+			GLM_FUNC_DECL explicit tvec3(A const & s, tvec2<B> const & v);
 			//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 			template <typename U> 
-			explicit tvec3(tvec3<U> const & v);
+			GLM_FUNC_DECL explicit tvec3(tvec3<U> const & v);
 			//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 			template <typename U> 
-			explicit tvec3(tvec4<U> const & v);
+			GLM_FUNC_DECL explicit tvec3(tvec4<U> const & v);
 
 			//////////////////////////////////////
 			// Unary arithmetic operators
 
-			tvec3<T> & operator= (tvec3<T> const & v);
+			GLM_FUNC_DECL tvec3<T> & operator= (tvec3<T> const & v);
 			template <typename U> 
-			tvec3<T> & operator= (tvec3<U> const & v);
+			GLM_FUNC_DECL tvec3<T> & operator= (tvec3<U> const & v);
 
 			template <typename U> 
-			tvec3<T> & operator+=(U const & s);
+			GLM_FUNC_DECL tvec3<T> & operator+=(U const & s);
 			template <typename U> 
-			tvec3<T> & operator+=(tvec3<U> const & v);
+			GLM_FUNC_DECL tvec3<T> & operator+=(tvec3<U> const & v);
 			template <typename U> 
-			tvec3<T> & operator-=(U const & s);
+			GLM_FUNC_DECL tvec3<T> & operator-=(U const & s);
 			template <typename U> 
-			tvec3<T> & operator-=(tvec3<U> const & v);
+			GLM_FUNC_DECL tvec3<T> & operator-=(tvec3<U> const & v);
 			template <typename U> 
-			tvec3<T> & operator*=(U const & s);
+			GLM_FUNC_DECL tvec3<T> & operator*=(U const & s);
 			template <typename U> 
-			tvec3<T> & operator*=(tvec3<U> const & v);
+			GLM_FUNC_DECL tvec3<T> & operator*=(tvec3<U> const & v);
 			template <typename U> 
-			tvec3<T> & operator/=(U const & s);
+			GLM_FUNC_DECL tvec3<T> & operator/=(U const & s);
 			template <typename U> 
-			tvec3<T> & operator/=(tvec3<U> const & v);
-			tvec3<T> & operator++();
-			tvec3<T> & operator--();
+			GLM_FUNC_DECL tvec3<T> & operator/=(tvec3<U> const & v);
+			GLM_FUNC_DECL tvec3<T> & operator++();
+			GLM_FUNC_DECL tvec3<T> & operator--();
 
 			//////////////////////////////////////
 			// Unary bit operators
 
 			template <typename U>
-			tvec3<T> & operator%= (U const & s);
+			GLM_FUNC_DECL tvec3<T> & operator%= (U const & s);
 			template <typename U>
-			tvec3<T> & operator%= (tvec3<U> const & v);
+			GLM_FUNC_DECL tvec3<T> & operator%= (tvec3<U> const & v);
 			template <typename U>
-			tvec3<T> & operator&= (U const & s);
+			GLM_FUNC_DECL tvec3<T> & operator&= (U const & s);
 			template <typename U>
-			tvec3<T> & operator&= (tvec3<U> const & v);
+			GLM_FUNC_DECL tvec3<T> & operator&= (tvec3<U> const & v);
 			template <typename U>
-			tvec3<T> & operator|= (U const & s);
+			GLM_FUNC_DECL tvec3<T> & operator|= (U const & s);
 			template <typename U>
-			tvec3<T> & operator|= (tvec3<U> const & v);
+			GLM_FUNC_DECL tvec3<T> & operator|= (tvec3<U> const & v);
 			template <typename U>
-			tvec3<T> & operator^= (U const & s);
+			GLM_FUNC_DECL tvec3<T> & operator^= (U const & s);
 			template <typename U>
-			tvec3<T> & operator^= (tvec3<U> const & v);
+			GLM_FUNC_DECL tvec3<T> & operator^= (tvec3<U> const & v);
 			template <typename U>
-			tvec3<T> & operator<<=(U const & s);
+			GLM_FUNC_DECL tvec3<T> & operator<<=(U const & s);
 			template <typename U>
-			tvec3<T> & operator<<=(tvec3<U> const & v);
+			GLM_FUNC_DECL tvec3<T> & operator<<=(tvec3<U> const & v);
 			template <typename U>
-			tvec3<T> & operator>>=(U const & s);
+			GLM_FUNC_DECL tvec3<T> & operator>>=(U const & s);
 			template <typename U>
-			tvec3<T> & operator>>=(tvec3<U> const & v);
+			GLM_FUNC_DECL tvec3<T> & operator>>=(tvec3<U> const & v);
 
 			//////////////////////////////////////
 			// Swizzle operators
 
-			value_type swizzle(comp X) const;
-			tvec2<T> swizzle(comp X, comp Y) const;
-			tvec3<T> swizzle(comp X, comp Y, comp Z) const;
-			tvec4<T> swizzle(comp X, comp Y, comp Z, comp W) const;
-			tref3<T> swizzle(comp X, comp Y, comp Z);
+			GLM_FUNC_DECL value_type swizzle(comp X) const;
+			GLM_FUNC_DECL tvec2<T> swizzle(comp X, comp Y) const;
+			GLM_FUNC_DECL tvec3<T> swizzle(comp X, comp Y, comp Z) const;
+			GLM_FUNC_DECL tvec4<T> swizzle(comp X, comp Y, comp Z, comp W) const;
+			GLM_FUNC_DECL tref3<T> swizzle(comp X, comp Y, comp Z);
 		};
 
 		template <typename T>
 		struct tref3
 		{
-			tref3(T & x, T & y, T & z);
-			tref3(tref3<T> const & r);
-			tref3(tvec3<T> const & v);
+			GLM_FUNC_DECL tref3(T & x, T & y, T & z);
+			GLM_FUNC_DECL tref3(tref3<T> const & r);
+			GLM_FUNC_DECL tref3(tvec3<T> const & v);
 
-			tref3<T> & operator= (tref3<T> const & r);
-			tref3<T> & operator= (tvec3<T> const & v);
+			GLM_FUNC_DECL tref3<T> & operator= (tref3<T> const & r);
+			GLM_FUNC_DECL tref3<T> & operator= (tvec3<T> const & v);
 
 			T & x;
 			T & y;
diff --git a/glm/core/type_vec4.hpp b/glm/core/type_vec4.hpp
index 7257ceb0..25135de4 100644
--- a/glm/core/type_vec4.hpp
+++ b/glm/core/type_vec4.hpp
@@ -40,7 +40,7 @@ namespace glm
 
 			typedef T value_type;
 			typedef std::size_t size_type;
-			static size_type value_size();
+			static GLM_FUNC_DECL size_type value_size();
 
 			typedef tvec4<T> type;
 			typedef tvec4<bool> bool_type;
@@ -67,23 +67,23 @@ namespace glm
 			//////////////////////////////////////
 			// Accesses
 
-			value_type & operator[](size_type i);
-			value_type const & operator[](size_type i) const;
+			GLM_FUNC_DECL value_type & operator[](size_type i);
+			GLM_FUNC_DECL value_type const & operator[](size_type i) const;
 
 			//////////////////////////////////////
 			// Implicit basic constructors
 
-			tvec4();
-			tvec4(type const & v);
+			GLM_FUNC_DECL tvec4();
+			GLM_FUNC_DECL tvec4(type const & v);
 
 			//////////////////////////////////////
 			// Explicit basic constructors
 
-			explicit tvec4(
+			GLM_FUNC_DECL explicit tvec4(
 				ctor);
-			explicit tvec4(
+			GLM_FUNC_DECL explicit tvec4(
 				value_type const & s);
-			explicit tvec4(
+			GLM_FUNC_DECL explicit tvec4(
 				value_type const & s0, 
 				value_type const & s1, 
 				value_type const & s2, 
@@ -92,18 +92,18 @@ namespace glm
 			//////////////////////////////////////
 			// Swizzle constructors
 
-			tvec4(tref4<T> const & r);
+			GLM_FUNC_DECL tvec4(tref4<T> const & r);
 
 			//////////////////////////////////////
 			// Convertion scalar constructors
 
 			//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 			template <typename U> 
-			explicit tvec4(
+			GLM_FUNC_DECL explicit tvec4(
 				U const & x);
 			//! 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> 
-			explicit tvec4(
+			GLM_FUNC_DECL explicit tvec4(
 				A const & x, 
 				B const & y, 
 				C const & z, 
@@ -114,99 +114,99 @@ namespace glm
 
 			//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 			template <typename A, typename B, typename C> 
-			explicit tvec4(tvec2<A> const & v, B const & s1, C const & s2);
+			GLM_FUNC_DECL explicit tvec4(tvec2<A> const & v, B const & s1, C const & s2);
 			//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 			template <typename A, typename B, typename C> 
-			explicit tvec4(A const & s1, tvec2<B> const & v, C const & s2);
+			GLM_FUNC_DECL explicit tvec4(A const & s1, tvec2<B> const & v, C const & s2);
 			//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 			template <typename A, typename B, typename C> 
-			explicit tvec4(A const & s1, B const & s2, tvec2<C> const & v);
+			GLM_FUNC_DECL explicit tvec4(A const & s1, B const & s2, tvec2<C> const & v);
 			//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 			template <typename A, typename B> 
-			explicit tvec4(tvec3<A> const & v, B const & s);
+			GLM_FUNC_DECL explicit tvec4(tvec3<A> const & v, B const & s);
 			//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 			template <typename A, typename B> 
-			explicit tvec4(A const & s, tvec3<B> const & v);
+			GLM_FUNC_DECL explicit tvec4(A const & s, tvec3<B> const & v);
 			//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 			template <typename A, typename B> 
-			explicit tvec4(tvec2<A> const & v1, tvec2<B> const & v2);
+			GLM_FUNC_DECL explicit tvec4(tvec2<A> const & v1, tvec2<B> const & v2);
 			//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 			template <typename U> 
-			explicit tvec4(tvec4<U> const & v);
+			GLM_FUNC_DECL explicit tvec4(tvec4<U> const & v);
 
 			//////////////////////////////////////
 			// Unary arithmetic operators
 
-			tvec4<T> & operator= (tvec4<T> const & v);
+			GLM_FUNC_DECL tvec4<T> & operator= (tvec4<T> const & v);
 			template <typename U>
-			tvec4<T> & operator= (tvec4<U> const & v);
+			GLM_FUNC_DECL tvec4<T> & operator= (tvec4<U> const & v);
 
 			template <typename U>
-			tvec4<T> & operator+=(U const & s);
+			GLM_FUNC_DECL tvec4<T> & operator+=(U const & s);
 			template <typename U>
-			tvec4<T> & operator+=(tvec4<U> const & v);
+			GLM_FUNC_DECL tvec4<T> & operator+=(tvec4<U> const & v);
 			template <typename U>
-			tvec4<T> & operator-=(U const & s);
+			GLM_FUNC_DECL tvec4<T> & operator-=(U const & s);
 			template <typename U>
-			tvec4<T> & operator-=(tvec4<U> const & v);
+			GLM_FUNC_DECL tvec4<T> & operator-=(tvec4<U> const & v);
 			template <typename U>
-			tvec4<T> & operator*=(U const & s);
+			GLM_FUNC_DECL tvec4<T> & operator*=(U const & s);
 			template <typename U>
-			tvec4<T> & operator*=(tvec4<U> const & v);
+			GLM_FUNC_DECL tvec4<T> & operator*=(tvec4<U> const & v);
 			template <typename U>
-			tvec4<T> & operator/=(U const & s);
+			GLM_FUNC_DECL tvec4<T> & operator/=(U const & s);
 			template <typename U>
-			tvec4<T> & operator/=(tvec4<U> const & v);
-			tvec4<T> & operator++();
-			tvec4<T> & operator--();
+			GLM_FUNC_DECL tvec4<T> & operator/=(tvec4<U> const & v);
+			GLM_FUNC_DECL tvec4<T> & operator++();
+			GLM_FUNC_DECL tvec4<T> & operator--();
 
 			//////////////////////////////////////
 			// Unary bit operators
 
 			template <typename U>
-			tvec4<T> & operator%= (U const & s);
+			GLM_FUNC_DECL tvec4<T> & operator%= (U const & s);
 			template <typename U>
-			tvec4<T> & operator%= (tvec4<U> const & v);
+			GLM_FUNC_DECL tvec4<T> & operator%= (tvec4<U> const & v);
 			template <typename U>
-			tvec4<T> & operator&= (U const & s);
+			GLM_FUNC_DECL tvec4<T> & operator&= (U const & s);
 			template <typename U>
-			tvec4<T> & operator&= (tvec4<U> const & v);
+			GLM_FUNC_DECL tvec4<T> & operator&= (tvec4<U> const & v);
 			template <typename U>
-			tvec4<T> & operator|= (U const & s);
+			GLM_FUNC_DECL tvec4<T> & operator|= (U const & s);
 			template <typename U>
-			tvec4<T> & operator|= (tvec4<U> const & v);
+			GLM_FUNC_DECL tvec4<T> & operator|= (tvec4<U> const & v);
 			template <typename U>
-			tvec4<T> & operator^= (U const & s);
+			GLM_FUNC_DECL tvec4<T> & operator^= (U const & s);
 			template <typename U>
-			tvec4<T> & operator^= (tvec4<U> const & v);
+			GLM_FUNC_DECL tvec4<T> & operator^= (tvec4<U> const & v);
 			template <typename U>
-			tvec4<T> & operator<<=(U const & s);
+			GLM_FUNC_DECL tvec4<T> & operator<<=(U const & s);
 			template <typename U>
-			tvec4<T> & operator<<=(tvec4<U> const & v);
+			GLM_FUNC_DECL tvec4<T> & operator<<=(tvec4<U> const & v);
 			template <typename U>
-			tvec4<T> & operator>>=(U const & s);
+			GLM_FUNC_DECL tvec4<T> & operator>>=(U const & s);
 			template <typename U>
-			tvec4<T> & operator>>=(tvec4<U> const & v);
+			GLM_FUNC_DECL tvec4<T> & operator>>=(tvec4<U> const & v);
 
 			//////////////////////////////////////
 			// Swizzle operators
 
-			value_type swizzle(comp X) const;
-			tvec2<T> swizzle(comp X, comp Y) const;
-			tvec3<T> swizzle(comp X, comp Y, comp Z) const;
-			tvec4<T> swizzle(comp X, comp Y, comp Z, comp W) const;
-			tref4<T> swizzle(comp X, comp Y, comp Z, comp W);
+			GLM_FUNC_DECL value_type swizzle(comp X) const;
+			GLM_FUNC_DECL tvec2<T> swizzle(comp X, comp Y) const;
+			GLM_FUNC_DECL tvec3<T> swizzle(comp X, comp Y, comp Z) const;
+			GLM_FUNC_DECL tvec4<T> swizzle(comp X, comp Y, comp Z, comp W) const;
+			GLM_FUNC_DECL tref4<T> swizzle(comp X, comp Y, comp Z, comp W);
 		};
 
 		template <typename T>
 		struct tref4
 		{
-			tref4(T & x, T & y, T & z, T & w);
-			tref4(tref4<T> const & r);
-			tref4(tvec4<T> const & v);
+			GLM_FUNC_DECL tref4(T & x, T & y, T & z, T & w);
+			GLM_FUNC_DECL tref4(tref4<T> const & r);
+			GLM_FUNC_DECL tref4(tvec4<T> const & v);
 
-			tref4<T> & operator= (tref4<T> const & r);
-			tref4<T> & operator= (tvec4<T> const & v);
+			GLM_FUNC_DECL tref4<T> & operator= (tref4<T> const & r);
+			GLM_FUNC_DECL tref4<T> & operator= (tvec4<T> const & v);
 
 			T & x;
 			T & y;