0.9.8 0.9.7 0.9.6 0.9.5 0.9.4 0.9.3 0.9.2 0.9.1 0.9.0

2016-09-11 - GLM released

  • Features:
  • Added right and left handed projection and clip control support #447 #415 #119
  • Added compNormalize and compScale functions to GTX_component_wise
  • Added packF3x9_E1x5 and unpackF3x9_E1x5 to GTC_packing for RGB9E5 #416
  • Added (un)packHalf to GTC_packing
  • Added (un)packUnorm and (un)packSnorm to GTC_packing
  • Added 16bit pack and unpack to GTC_packing
  • Added 8bit pack and unpack to GTC_packing
  • Added missing bvec* && and || operators
  • Added iround and uround to GTC_integer, fast round on positive values
  • Added raw SIMD API
  • Added 'aligned' qualifiers
  • Added GTC_type_aligned with aligned vec types
  • Added GTC_functions extension
  • Added quaternion version of isnan and isinf #521
  • Added lowestBitValue to GTX_bit #536
  • Added GLM_FORCE_UNRESTRICTED_GENTYPE allowing non basic genType #543

  • Improvements:
  • Improved SIMD and swizzle operators interactions with GCC and Clang #474
  • Improved GTC_random linearRand documentation
  • Improved GTC_reciprocal documentation
  • Improved GLM_FORCE_EXPLICIT_CTOR coverage #481
  • Improved OpenMP support detection for Clang, GCC, ICC and VC
  • Improved GTX_wrap for SIMD friendliness
  • Added constexpr for vec, mat, quat and dual_quat types #493
  • Added NEON instruction set detection
  • Added MIPS CPUs detection
  • Added PowerPC CPUs detection
  • Use Cuda built-in function for abs function implementation with Cuda compiler
  • No more warnings for use of long long
  • Added more information to build messages

  • Fixes:
  • Fixed GTX_extended_min_max filename typo #386
  • Fixed intersectRayTriangle to not do any unintentional backface culling
  • Fixed long long warnings when using C++98 on GCC and Clang #482
  • Fixed sign with signed integer function on non-x86 architecture
  • Fixed strict aliasing warnings #473
  • Fixed missing vec1 overload to length2 and distance2 functions #431
  • Fixed GLM test '/fp:fast' and '/Za' command-line options are incompatible
  • Fixed quaterion to mat3 cast function mat3_cast from GTC_quaternion #542
  • Fixed GLM_GTX_io for Cuda #547 #546

  • Deprecation:
  • Removed GLM_FORCE_SIZE_FUNC define
  • Deprecated GLM_GTX_simd_vec4 extension
  • Deprecated GLM_GTX_simd_mat4 extension
  • Deprecated GLM_GTX_simd_quat extension
  • Deprecated GLM_SWIZZLE, use GLM_FORCE_SWIZZLE instead
  • Deprecated GLM_MESSAGES, use GLM_FORCE_MESSAGES instead

  • Download: GLM (ZIP, 4.2 MB) (7Z, 3.1 MB)

  • 2016-07-16 - GLM released

    • Improvements:
    • Added pkg-config file #509
    • Updated list of compiler versions detected
    • Improved C++ 11 STL detection #523

    • Fixes:
    • Fixed STL for C++11 detection on ICC #510
    • Fixed missing vec1 overload to length2 and distance2 functions #431
    • Fixed long long warnings when using C++98 on GCC and Clang #482
    • Fixed scalar reciprocal functions (GTC_reciprocal) #520

  • Download: GLM (ZIP, 4.2 MB) (7Z, 2.8 MB)

  • 2016-05-24 - GLM released

    • Improvements:
    • Added Visual C++ Clang toolset detection

    • Fixes:
    • Fixed uaddCarry warning #497
    • Fixed roundPowerOfTwo and floorPowerOfTwo #503
    • Fixed Visual C++ SIMD instruction set automatic detection in 64 bits
    • Fixed to_string when used with GLM_FORCE_INLINE #506
    • Fixed GLM_FORCE_INLINE with binary vec4 operators

  • Download: GLM (ZIP, 4.2 MB) (7Z, 2.8 MB)

  • 2016-03-19 - GLM released

    • Fixes:
    • Fixed asinh and atanh warning with C++98 STL #484
    • Fixed polar coordinates function latitude #485
    • Fixed outerProduct defintions and operator signatures for mat2x4 and vec4 #475
    • Fixed eulerAngles precision error, returns NaN #451
    • Fixed undefined reference errors #489
    • Fixed missing GLM_PLATFORM_CYGWIN declaration #495
    • Fixed various undefined reference errors #490

  • Download: GLM (ZIP, 4.2 MB) (7Z, 2.8 MB)

  • 2016-02-21 - GLM released

    • Improvements:
    • Added AVX512 detection

    • Fixes:
    • Fixed CMake policy warning
    • Fixed GCC 6.0 detection #477
    • Fixed Clang build on Windows #479
    • Fixed 64 bits constants warnings on GCC #463

  • Download: GLM (ZIP, 4.2 MB) (7Z, 2.8 MB)

  • 2016-01-03 - GLM released

    • Fixes:
    • Fixed GTC_round floorMultiple/ceilMultiple #412
    • Fixed GTC_packing unpackUnorm3x10_1x2 #414
    • Fixed GTC_matrix_inverse affineInverse #192
    • Fixed ICC on Linux build errors #449
    • Fixed ldexp and frexp compilation errors #456 #466
    • Fixed "Declaration shadows a field" warning #468
    • Fixed 'GLM_COMPILER_VC2005 is not defined' warning #468
    • Fixed various 'X is not defined' warnings #468
    • Fixed missing unary + operator #435
    • Fixed Cygwin build errors when using C++11 #405

  • Download: GLM (ZIP, 4.2 MB) (7Z, 2.8 MB)

  • 2015-09-07 - GLM released

    • Improvements:
    • Improved constexpr for constant functions coverage #198
    • Added to_string for quat and dual_quat in GTX_string_cast #375
    • Improved overall execution time of unit tests #396

    • Fixes:
    • Fixed strict alignment warnings #235 #370
    • Fixed link errors on compilers not supported default function #377
    • Fixed compilation warnings in vec4
    • Fixed non-identity quaternions for equal vectors #234
    • Fixed excessive GTX_fast_trigonometry execution time #396
    • Fixed Visual Studio 2015 'hides class member' warnings #394
    • Fixed builtin bitscan never being used #392
    • Removed unused func_noise.* files #398

  • Download: GLM (ZIP, 4.2 MB) (7Z, 2.8 MB)

  • 2015-08-02 - GLM released

    • Features:
    • Added GTC_color_space: convertLinearToSRGB and convertSRGBToLinear functions
    • Added 'fmod' overload to GTX_common with tests #308
    • Added left handed perspective and lookAt functions #314
    • Added functions eulerAngleXYZ and extractEulerAngleXYZ #311
    • Added GTX_hash to perform std::hash on GLM types #320 #367
    • Added GTX_wrap for texcoord wrapping
    • Added static components and precision members to all vector and quat types #350
    • Added .gitignore #349
    • Added support of defaulted functions to GLM types, to use them in unions #366

    • Improvements:
    • Changed usage of __has_include to support Intel compiler #307
    • Specialized integer implementation of YCoCg-R #310
    • Don't show status message in 'FindGLM' if 'QUIET' option is set. #317
    • Added master branch continuous integration service on Linux 64 #332
    • Clarified manual regarding angle unit in GLM, added FAQ 11 #326
    • Updated list of compiler versions

    • Fixes:
    • Fixed default precision for quat and dual_quat type #312
    • Fixed (u)int64 MSB/LSB handling on BE archs #306
    • Fixed multi-line comment warning in g++ #315
    • Fixed specifier removal by 'std::make_pair' #333
    • Fixed perspective fovy argument documentation #327
    • Removed -m64 causing build issues on Linux 32 #331
    • Fixed isfinite with C++98 compilers #343
    • Fixed Intel compiler build error on Linux #354
    • Fixed use of libstdc++ with Clang #351
    • Fixed quaternion pow #346
    • Fixed decompose warnings #373
    • Fixed matrix conversions #371

    • Deprecation:
    • Removed integer specification for 'mod' in GTC_integer #308
    • Removed GTX_multiple, replaced by GTC_round

  • Download: GLM (ZIP, 4.2 MB) (7Z, 2.8 MB)

  • 15/02/2015 - GLM released

    • Fixes:
    • Fixed Android doesn't have C++ 11 STL #284

  • Download: GLM (ZIP, 4.1 MB) (7Z, 2.7 MB)

  • 15/02/2015 - GLM released

    • Features:
    • Added display of GLM version with other GLM_MESSAGES
    • Added ARM instruction set detection

    • Improvements:
    • Removed assert for perspective with zFar < zNear #298
    • Added Visual Studio natvis support for vec1, quat and dualqual types
    • Cleaned up C++11 feature detections
    • Clarify GLM licensing

    • Fixes:
    • Fixed faceforward build #289
    • Fixed conflict with Xlib #define True 1 #293
    • Fixed decompose function VS2010 templating issues #294
    • Fixed mat4x3 = mat2x3 * mat4x2 operator #297
    • Fixed warnings in F2x11_1x10 packing function in GTC_packing #295
    • Fixed Visual Studio natvis support for vec4 #288
    • Fixed GTC_packing *pack*norm*x* build and added tests #292
    • Disabled GTX_scalar_multiplication for GCC, failing to build tests #242
    • Fixed Visual C++ 2015 constexpr errors: Disabled only partial support
    • Fixed functions not inlined with Clang #302
    • Fixed memory corruption (undefined behaviour) #303

  • Download: GLM (ZIP, 4.1 MB) (7Z, 2.7 MB)

  • 10/12/2014 - GLM released

    GLM came with its set of major glitches: C++98 only mode, 32 bit build, Cuda and Android support should all be fixed in GLM release.

    • Features:
    • Added GLM_LANG_CXX14_FLAG and GLM_LANG_CXX1Z_FLAG language feature flags
    • Added C++14 detection

    • Improvements:
    • Clean up GLM_MESSAGES compilation log to report only detected capabilities

    • Fixes:
    • Fixed scalar uaddCarry build error with Cuda #276
    • Fixed C++11 explicit conversion operators detection #282
    • Fixed missing explicit convertion when using integer log2 with *vec1 types
    • Fixed 64 bits integer GTX_string_cast to_string on VC 32 bit compiler
    • Fixed Android build issue, STL C++11 is not supported by the NDK #284
    • Fixed unsupported _BitScanForward64 and _BitScanReverse64 in VC10
    • Fixed Visual C++ 32 bit build #283
    • Fixed GLM_FORCE_SIZE_FUNC pragma message
    • Fixed C++98 only build
    • Fixed conflict between GTX_compatibility and GTC_quaternion #286
    • Fixed C++ language restriction using GLM_FORCE_CXX**

  • Download: GLM (ZIP, 4.1 MB) (7Z, 2.7 MB)

  • 30/11/2014 - GLM released

    GLM is available with many changes.

    Transition from degrees to radians compatibility break and GLM help

    One of the long term issue with GLM is that some functions were using radians, functions from GLSL and others were using degrees, functions from GLU or legacy OpenGL.

    In GLM 0.9.5, we can use GLM_FORCE_RADIANS to force all GLM functions to adopt radians.

    In GLM 0.9.5 in degrees:
    • #include <glm/mat4.hpp>
    • #include <glm/gtc/matrix_tansform.hpp>
    • glm::mat4 my_rotateZ(glm::mat4 const & m, float angleInRadians)
    • {
    • return glm::rotate(m, glm::degrees(angleInRadians), glm::vec3(0.0, 0.0, 1.0));
    • }
    In GLM 0.9.5 in radians:
    • #define GLM_FORCE_RADIANS
    • #include <glm/mat4.hpp>
    • #include <glm/gtc/matrix_tansform.hpp>
    • glm::mat4 my_rotateZ(glm::mat4 const & m, float angleInRadians)
    • {
    • return glm::rotate(m, angleInRadians, glm::vec3(0.0, 0.0, 1.0));
    • }
    In GLM 0.9.6 in radians only:
    • #include <glm/mat4.hpp>
    • #include <glm/gtc/matrix_tansform.hpp>
    • glm::mat4 my_rotateZ(glm::mat4 const & m, float angleInRadians)
    • {
    • return glm::rotate(m, angleInRadians, glm::vec3(0.0, 0.0, 1.0));
    • }
    In GLM 0.9.6 if you what to use degrees anyway:
    • #include <glm/mat4.hpp>
    • #include <glm/gtc/matrix_tansform.hpp>
    • glm::mat4 my_rotateZ(glm::mat4 const & m, float angleInDegrees)
    • {
    • return glm::rotate(m, glm::radians(angleInDegrees), glm::vec3(0.0, 0.0, 1.0));
    • }

    GLM 0.9.5 will show warning messages at compilation each time a function taking degrees is used.

    GLM: rotate function taking degrees as a parameter is deprecated. #define GLM_FORCE_RADIANS before including GLM headers to remove this message.

    If you are using a version of GLM older than GLM, update to GLM before transitioning to GLM 0.9.6 to get this help in that process.

    Make sure to build and run successfully your application with GLM 0.9.5 with GLM_FORCE_RADIANS, before transistioning to GLM 0.9.6

    Finally, here is a list of all the functions that could use degrees in GLM that requires radians in GLM 0.9.6: rotate (matrices and quaternions), perspective, perspectiveFov, infinitePerspective, tweakedInfinitePerspective, roll, pitch, yaw, angle, angleAxis, polar, euclidean, rotateNormalizedAxis, rotateX, rotateY, rotateZ and orientedAngle.

    Using GLM template types

    There are a lot of reasons for using template types: Writing new template classes and functions or defining new types. Unfortunately, until GLM 0.9.5, GLM template types were defined into the detail namespace indicating there are implementation details that may changed.

    With GLM 0.9.6, template types are accessible from the GLM namespace and guarantee to be stable onward.

    Example of template functions, GLM 0.9.5 and 0.9.6 style:
    • #include <glm/geometry.hpp>
    • #include <glm/exponential.hpp>
    • template <typename vecType>
    • typename vecType::value_type normalizeDot(vecType const & a, vecType const & b)
    • {
    • return glm::dot(a, b) * glm::inversesqrt(glm::dot(a, a) * glm::dot(b, b));
    • }
    • #include <glm/vec4.hpp>
    • int main()
    • {
    • return normalizeDot(glm::vec4(2.0), glm::vec4(2.0)) > 0.0f ? 0 : 1
    • }
    Example of template functions, alternative GLM 0.9.6 style:
    • #include <glm/geometry.hpp>
    • #include <glm/exponential.hpp>
    • template <typename T, template <typename, glm::precision> class vecType>
    • T normalizeDot(vecType<T, P> const & a, vecType<T, P> const & b)
    • {
    • return glm::dot(a, b) * glm::inversesqrt(glm::dot(a, a) * glm::dot(b, b));
    • }
    • #include <glm/vec4.hpp>
    • int main()
    • {
    • return normalizeDot(glm::vec4(2.0), glm::vec4(2.0)) > 0.0f ? 0 : 1
    • }
    Example of typedefs with GLM 0.9.6:
    • #include <cstddef>
    • #include <glm/vec4.hpp>
    • #include <glm/mat4.hpp>
    • typedef glm::tvec4<std::size_t> size4;
    • typedef glm::tvec4<long double, glm::highp> ldvec4;
    • typedef glm::tmat4x4<long double, glm::highp> ldmat4x4;

    With GLM 0.9.5, the library started to tackle the issue of compilation time by introducing forward declarations through <glm/fwd.hpp> but also by providing an alternative to the monolithic <glm/glm.hpp> headers with <glm/vec2.hpp>, <glm/mat3x2.hpp> and <glm/common.hpp>, etc.

    With GLM 0.9.6, the library took advantage of dropping old compilers to replace preprocessor instantiation of the code by template instantiation. The issue of preprocessor instantiation (among them!) is that all the code is generated even if it is never used resulting in building and compiling much bigger header files.

    Furthermore, a lot of code optimizations have been done to provide better performance at run time by leveraging integer bitfield tricks and compiler intrinsics. The test framework has been extended to include performance tests. The total code size of the tests is now 50% of the library code which is still not enough but pretty solid.

    Compilers support

    GLM 0.9.6 removed support for a lot of old compiler versions. If you are really insisting in using an older compiler, you are welcome to keep using GLM 0.9.5.

    • Supported compilers by GLM 0.9.6:
    • Apple Clang 4.0 and higher
    • CUDA 4.0 and higher
    • GCC 4.4 and higher
    • LLVM 3.0 and higher
    • Intel C++ Composer XE 2013 and higher
    • Visual Studio 2010 and higher
    • Any conform C++98 compiler


    Finally, GLM is changing Lisence to adopt the Happy Bunny Lisence.

    Release note

    • Features:
    • Exposed template vector and matrix types in 'glm' namespace #239, #244
    • Added GTX_scalar_multiplication for C++ 11 compiler only #242
    • Added GTX_range for C++ 11 compiler only #240
    • Added closestPointOnLine function for tvec2 to GTX_closest_point #238
    • Added GTC_vec1 extension, *vec1 support to *vec* types
    • Updated GTX_associated_min_max with vec1 support
    • Added support of precision and integers to linearRand #230
    • Added Integer types support to GTX_string_cast #249
    • Added vec3 slerp #237
    • Added GTX_common with isdenomal #223
    • Added GLM_FORCE_SIZE_FUNC to replace .length() by .size() #245
    • Added 'uninitialize' to explicitly not initialize a GLM type
    • Added GTC_bitfield extension, promoted GTX_bit
    • Added GTC_integer extension, promoted GTX_bit and GTX_integer
    • Added GTC_round extension, promoted GTX_bit
    • Added GLM_FORCE_EXPLICIT_CTOR to require explicit type conversions #269
    • Added GTX_type_aligned for aligned vector, matrix and quaternion types

    • Improvements:
    • Rely on C++11 to implement isinf and isnan
    • Removed GLM_FORCE_CUDA, Cuda is implicitly detected
    • Separated Apple Clang and LLVM compiler detection
    • Used pragma once
    • Undetected C++ compiler automatically compile with GLM_FORCE_CXX98 and GLM_FORCE_PURE
    • Added not function (from GLSL specification) on VC12
    • Optimized bitfieldReverse and bitCount functions
    • Optimized findLSB and findMSB functions
    • Optimized matrix-vector multiple performance with Cuda #257, #258
    • Reduced integer type redifinitions #233
    • Rewrited of GTX_fast_trigonometry #264 #265
    • Made types trivially copyable #263
    • Removed iostream in GLM tests
    • Used std features within GLM without redeclaring
    • Optimized cot function #272
    • Optimized sign function #272
    • Added explicit cast from quat to mat3 and mat4 #275

    • Fixes:
    • Fixed std::nextafter not supported with C++11 on Android #217
    • Fixed missing value_type for dual quaternion
    • Fixed return type of dual quaternion length
    • Fixed infinite loop in isfinite function with GCC #221
    • Fixed Visual Studio 14 compiler warnings
    • Fixed implicit conversion from another tvec2 type to another tvec2 #241
    • Fixed lack of consistency of quat and dualquat constructors
    • Fixed uaddCarray #253
    • Fixed float comparison warnings #270

    • Deprecation:
    • Removed degrees for function parameters
    • Removed GLM_FORCE_RADIANS, active by default
    • Removed VC 2005 / 8 and 2008 / 9 support
    • Removed GCC 3.4 to 4.5 support
    • Removed LLVM GCC support
    • Removed LLVM 2.6 to 2.9 support
    • Removed CUDA 3.0 to 4.0 support


    21/06/2014 - GLM released

    • Changelog:
    • Added GTX_io for io with 'iostream' #144
    • Added FindGLM install for CMake #189
    • Optimized quaternion vector rotation #205
    • Fixed non-utf8 character #196
    • Fixed GTX_color_space - saturation #195
    • Fixed glm::isinf and glm::isnan for with Android NDK 9d #191
    • Fixed builtin GLM_ARCH_SSE4 #204
    • Fixed missing doxygen @endcond tag #211
    • Fixed instruction set detection with Clang #158
    • Fixed orientate3 function #207
    • Fixed lerp when cosTheta is close to 1 in quaternion slerp #210
    • Fixed fastDistance ambiguity #215
    • Fixed tweakedInfinitePerspective #208 and added user-defined epsilon to tweakedInfinitePerspective
    • Fixed std::copy and std::vector with GLM types #214
    • Fixed strict aliasing issues #212, #152
    • Fixed std::nextafter not supported with C++11 on Android #213
    • Fixed corner cases in exp and log functions for quaternions #199

    02/04/2014 - GLM released

    • Changelog:
    • Added instruction set auto detection with Visual C++ using _M_IX86_FP - /arch compiler argument
    • Fixed GTX_raw_data code dependency
    • Fixed GCC instruction set detection
    • Added GLM_GTX_matrix_transform_2d extension (#178, #176)
    • Fixed CUDA issues (#169, #168, #183, #182)
    • Added support for all extensions but GTX_string_cast to CUDA
    • Fixed strict aliasing warnings in GCC 4.8.1 / Android NDK 9c (#152)
    • Fixed missing bitfieldInterleave definitions
    • Fixed usubBorrow (#171)
    • Fixed eulerAngle*** not consistent for right-handed coordinate system (#173)
    • Added full tests for eulerAngle*** functions (#173)
    • Added workaround for a CUDA compiler bug (#186, #185)

    08/02/2014 - GLM released

    C++ 11 introduced initializer lists and uniform initialization syntax and GLM tried to leverage this functionality but didn't get it quite right. GLM is fixing this.

    Examples of usage with GLM:
    • #define GLM_FORCE_RADIANS
    • #include <glm/vec4.hpp>
    • #include <glm/mat4.hpp>
    • #include <glm/gtc/quat.hpp>
    • {
    • ...
    • glm::vec4 A{0, 1, 2, 3};
    • glm::mat4 B{
    • {0, 1, 2, 3},
    • {4, 5, 6, 7},
    • {8, 9, 10, 11},
    • {12, 13, 14, 15}};
    • std::vector<glm::mat4> C{
    • {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15},
    • {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}};
    • std::vector<glm::mat4> D{
    • {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15},
    • {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}};
    • std::vector<glm::mat4> E{
    • {
    • { 0, 1, 2, 3 },
    • { 4, 5, 6, 7 },
    • { 8, 9, 10, 11 },
    • { 12, 13, 14, 15 }
    • },
    • {
    • { 0, 1, 2, 3 },
    • { 4, 5, 6, 7 },
    • { 8, 9, 10, 11 },
    • { 12, 13, 14, 15 }
    • }};
    • glm::quat F{0, 1, 2, 3};
    • ...
    • }

    • Changelog:
    • Fixed initializer list ambiguity (#159, #160)
    • Fixed warnings with the Android NDK 9c
    • Fixed non power of two matrix products
    • Fixed mix function link error
    • Fixed SSE code included in GLM tests on "pure" platforms
    • Fixed undefined reference to fastInverseSqrt (#161)
    • Fixed GLM_FORCE_RADIANS with <glm/ext.hpp> build error (#165)
    • Fix dot product clamp range for vector angle functions. (#163)
    • Tentative fix for strict aliasing warning in GCC 4.8.1 / Android NDK 9c (#152)
    • Fixed GLM_GTC_constants description brief (#162)

    11/01/2013 - GLM released

    One of the annoying aspect of GLM is that sometime angles are expressed in degrees and sometime angles are expressed in radians. Angles expressed in radians are features coming from GLSL where all the angles are expressed in radians and angles expressed in degrees are features coming from OpenGL compatibility profile.

    GLM provides the define GLM_FORCE_RADIANS to enfore all the angles to be radians. GLM 0.9.5 deprecates degrees so that in GLM 0.9.6 those will be removed. Starting with GLM, warnings will be prompt for each instance of usage degrees. This is designed to help transitioning user code. Defining GLM_FORCE_RADIANS will quiet these messages.

    Transitioning degrees to radians:
    • #define GLM_FORCE_RADIANS
    • #include <glm/gtc/matrix_tansform.hpp>
    • #include <glm/gtc/constants.hpp>
    • void transitioning_to_radians()
    • {
    • ...
    • glm::mat4 m1 = glm::rotate(glm::mat4(1.f), glm::radians(45.0f), glm::vec3(0.0, 0.0, 1.0));
    • glm::mat4 m2 = glm::rotate(glm::mat4(1.f), glm::pi<float>() * 0.25f, glm::vec3(0.0, 0.0, 1.0));
    • ...
    • }

    GLM is also fixing multiple bugs essentially related to the new approach allowing to include each feature individually.

    • Changelog:
    • Fixed angle and orientedAngle that sometimes return NaN values (#145)
    • Deprecated degrees for function parameters and display a message
    • Added possible static_cast conversion of GLM types (#72)
    • Fixed error 'inverse' is not a member of 'glm' from glm::unProject (#146)
    • Fixed mismatch between some declarations and definitions
    • 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)

    25/12/2013 - GLM released

    GLM 0.9.5 broke compatibility with GLM 0.9.4 to bring multiple improvements on multiple fronts: compilation time, generated code performances and usage reliability.

    First, in previous version GLM switched from including <glm/ext.hpp> to include individual extensions. Just like we can still use <glm/ext.hpp> for global inclusion, with GLM 0.9.5 we can use individual headers to include only the features we need. For example: <glm/vec3.hpp> for glm::vec3, <glm/mat4x4.hpp> for glm::mat4 or <glm/geometry.hpp> for all the version of the geometry section of the GLSL specifications.

    Futhermore, GLM has a new forward declaration header <glm/fwd.hpp> to help reducing dependecies to GLM code.

    As a result and for experimentation, a simple raytracer can be compile in less than half the time with GLM 0.9.5 than GLM 0.9.4.

    Second, the definition of the precision qualifier (lowp, mediump and highp) has changed and now express computation precision in term of ULPs. As a conscequence for example sizeof(glm::lowp_vec2), sizeof(glm::mediump_vec2) and sizeof(glm::highp_vec2) return the same values. However, the effective computation can be different. For example, the implementation of inversesqrt uses fast inverse square root for lowp.

    Finally, some efforts have be put into increasing reliability with a larger coverage of assert and static_assert to give more informative compiler error messages. Also, all the half based type have been deleted. These types could be used just like any float of double types but such usage were bad usages requiring a lot of conversions from half to float and float to half, hence very slow performances. Instead, GLM 0.9.5 provides a extensive set of packing and unpacking functions (glm/gtc/packing.hpp) so that we have to perform arithmetics in float and when it's done we pack it in half data.

    For more details, see the changelog following, enjoy!

    • Changelog:
    • Added forward declarations (glm/fwd.hpp) for faster compilations
    • Added per feature headers
    • Minimized GLM internal dependencies
    • Improved Intel Compiler detection
    • Added bitfieldInterleave and _mm_bit_interleave_si128 functions
    • Added GTX_scalar_relational
    • Added GTX_dual_quaternion
    • Added rotation function to GTX_quaternion (#22)
    • Added precision variation of each type
    • Added quaternion comparison functions
    • Fixed GTX_multiple for negative value
    • Removed GTX_ocl_type extension
    • Fixed post increment and decrement operators
    • Fixed perspective with zNear == 0 (#71)
    • Removed l-value swizzle operators
    • Cleaned up compiler detection code for unsupported compilers
    • Replaced C cast by C++ casts
    • Fixed .length() that should return a int and not a size_t
    • Added GLM_FORCE_SIZE_T_LENGTH and glm::length_t
    • Removed unnecessary conversions
    • Optimized packing and unpacking functions
    • Removed the normalization of the up argument of lookAt function (#114)
    • Added low precision specializations of inversesqrt
    • Fixed ldexp and frexp implementations
    • Increased assert coverage
    • Increased static_assert coverage
    • Replaced GLM traits by STL traits when possible
    • Allowed including individual core feature
    • Increased unit tests completness
    • Added creating of a quaternion from two vectors
    • Added C++11 initializer lists
    • Fixed umulExtended and imulExtended implementations for vector types (#76)
    • Fixed CUDA coverage for GTC extensions
    • Added GTX_io extension
    • Improved GLM messages enabled when defining GLM_MESSAGES
    • Hidden matrix _inverse function implementation detail into private section

    20/09/2013 - GLM released

    New revision of GLM 0.9.4 available thanks to user contributions.

    • Changelog:
    • Fixed detection to select the last known compiler if newer version #106
    • Fixed is_int and is_uint code duplication with GCC and C++11 #107
    • Fixed test suite build while using Clang in C++11 mode
    • Added c++1y mode support in CMake test suite
    • Added pedantic mode to CMake test suite for Clang and GCC
    • Added use of GCC frontend on Unix for ICC and Visual C++ fronted on Windows for ICC
    • Added compilation errors for unsupported compiler versions
    • Removed ms extension mode to CMake when no using Visual C++
    • Fixed glm::orientation with GLM_FORCE_RADIANS defined #112
    • Fixed const ref issue on assignment operator taking a scalar parameter #116
    • Fixed glm::eulerAngleY implementation

    13/08/2013 - GLM released

    GLM is available fixing the following minor issues. This is the occasion to also launch the revised GLM website.

    • Changelog:
    • Fixed inclusion of intrinsics in "pure" mode #92
    • Fixed language detection on GCC when the C++0x mode isn't enabled #95
    • Fixed issue #97: register is deprecated in C++11
    • Fixed issue #96: CUDA issues
    • Added Windows CE detection #92

    29/05/2013 - GLM released

    • Changelog:
    • Fixed slerp when costheta is close to 1 #65
    • Fixed mat4x2 value_type constructor #70
    • Fixed glm.natvis for Visual C++ 12 #82
    • Added assert in inversesqrt to detect division by zero #61
    • Fixed missing swizzle operators #86
    • Fixed CUDA warnings #86
    • Fixed GLM natvis for VC11 #82
    • Fixed GLM_GTX_multiple with negative values #79
    • Fixed glm::perspective when zNear is zero #71

    27/05/2013 - GLM packages for Linux

    GLM is now included in many major Linux distributions. Here is a quick list of available packages.

    Thanks to the package maintainers for these contributions!

    20/03/2013 - GLM released

    • Changelog:
    • Detected qualifier for Clang
    • Fixed C++11 mode for GCC, couldn't be enabled without MS extensions
    • Fixed squad, intermediate and exp quaternion functions
    • Fixed GTX_polar_coordinates euclidean function, takes a vec2 instead of a vec3
    • Clarify the license applying on the manual
    • Added a docx copy of the manual
    • Fixed GLM_GTX_matrix_interpolation
    • Fixed isnan and isinf on Android with Clang
    • Autodetected C++ version using __cplusplus value
    • Fixed mix for bool and bvec* third parameter

    14/02/2013 - GLM released

    A new revision of GLM is available. It fixes the following issues.

    • Changelog:
    • Fixed compAdd from GTX_component_wise
    • Fixed SIMD support for Intel compiler on Windows
    • Fixed isnan and isinf for CUDA compiler
    • Fixed GLM_FORCE_RADIANS on glm::perspective
    • Fixed GCC warnings
    • Fixed packDouble2x32 on XCode
    • Fixed mix for vec4 SSE implementation
    • Fixed 0x2013 dash character in comments that cause issue in Windows Japanese mode
    • Fixed documentation warnings
    • Fixed CUDA warnings

    22/12/2012 - GLM released

    GLM fixes various bugs and clarifies quaternion interpolations. There are now three different functions now: mix, slerp and lerp.

    lerp performs a linear interpolation between two quaternions. This operation is only defined with interpolation factors between [0, 1] and doesn't perform the rotation at constant speed. slerp perform a spherical linear interpolation between two quaternion. It always takes the short rotation path and it is performed at constant speed for interpolation factors between ]-inf, +inf[. This function is similar to the old shortMix function. mix is an oriented spherical linear interpolation between two quaternion. It is performed at constant speed for interpolation factors between ]-inf, +inf[.

    • Changelog:
    • Improved half support: -0.0 case and implicit conversions
    • Fixed Intel Composer Compiler support on Linux
    • Fixed interaction between quaternion and euler angles
    • Fixed GTC_constants build
    • Fixed quat slerp using mix function when cosTheta close to 1
    • Improved fvec4SIMD and fmat4x4SIMD implementations
    • Fixed assert messages
    • Added slerp and lerp quaternion functions and tests

    18/11/2012 - GLM released

    • Changelog:
    • Added Intel Composer Compiler support
    • Promoted GLM_GTC_espilon extension
    • Promoted GLM_GTC_ulp extension
    • Removed GLM website from the source repository
    • Added GLM_FORCE_RADIANS so that all functions takes radians for arguments
    • Fixed detection of Clang and LLVM GCC on MacOS X
    • Added debugger visualizers for Visual C++ 2012
    • Etc.

    30/06/2012 - GLM released

    GLM fixes quite few issues with GCC.

    • Changelog:
    • Fixed incompatibility generated with GCC
    • Fixed C++11 compiler option for GCC
    • Removed MS language extension option for GCC
    • Fixed bitfieldExtract for vector types
    • Fixed warnings
    • Fixed SSE includes

    If you encounter bugs, don't hesitate to report them.

    10/05/2012 - GLM released

    Nearly two months since the previous release of a GLM revision gave enough time to fix few things reported. Most importantly, this revision should provide a better compatibility with Intel C++ compiler.

    • Changelog:
    • Fixed isinf and isnan
    • Improved compatibility with Intel compiler
    • Added CMake test build options: SIMD, C++11, fast math and MS land ext
    • Fixed SIMD mat4 test on GCC
    • Fixed perspectiveFov implementation
    • Fixed matrixCompMult for none-square matrices
    • Fixed namespace issue on stream operators
    • Fixed various warnings
    • Added VC11 support

    If you encounter bugs, don't hesitate to report them.

    15/03/2012 - GLM released

    Just a regular revision fixing the only three minor issues reported since last release.

    10/03/2012 - GLM on GitHub

    After years of using, GLM is moving to GitHub, as least for its repository. GitHub provides easy ways to clone the repository and submit pull requests which seems a definity advantage for the community contribution. It also allows to download snapshots of every branches.

  • Browse GLM repository on GitHub
  • GLM master branch snapshot
  • GLM 0.9.3 branch snapshot
  • GLM 0.9.4 branch snapshot

  • 25/01/2012 - GLM released

    GLM fixes some platforms detection issues and warnings.

  • GLM (zip)
  • GLM (7z)
  • Submit a bug report
  • GLM 0.9.3 Manual
  • GLM 0.9.3 API

  • 09/01/2012 - GLM released

    GLM is finally released. Since the branch 0.9.2, the test bench and the Doxygen API documentation has been expended significantly leading to an even more reliable implementation and hopefully an even smoother development experience.

    For the feature set, the GLSL noise functions are added, based on the implementation of webgl-noise. Some users might prefer the promoted GLM_GTC_noise extension also based on webgl-noise but with a different interface and three noise methods: Perlin noise, periodic noise and simplex noise.

    2D simplex noise with GLM_GTC_noise
    2D simplex noise with GLM_GTC_noise

    Additionally, the random number generation functions (GLM_GTC_random) which provides various interesting distributions as illustrated below. Also reaching GLM tool box, the new experimental extension GLM_GTX_constants provides a set of constants.

    Spherical random distribution with GLM_GTC_random
    Spherical random distribution with GLM_GTC_random

    Finally, swizzle operators are a challenging task to implement but thanks to the effort of many contributors, GLM provides something interesting, but admittably not perfect. The new implementation is a great improvement considering the incompatibilities with some external libraries in GLM GLM 0.9.3 provides two implemetanations, one for C++ 98 compilers and one for C++ 11 compilers providing an implemetnation closer to what GLSL does. Indeed the C++ 98 implementation is compatible with C++ 11 compilers.

    Implementation for C++ 98 compilers:
    • // To declare before including glm.hpp, to use the swizzle operators
    • #define GLM_SWIZZLE
    • #include <glm/glm.hpp>
    • void example_cpp98()
    • {
    • glm::vec4 a = glm::vec4(2, 0, 0, 0);
    • glm::vec4 b = glm::vec4(0, 2, 0, 0);
    • glm::vec3 c = vec4((a.zyx() + * 0.5f, 1.0f);
    • glm::vec2 d = glm::normalize(glm::vec2(c.yz()));
    • a.xyzw() = d.xyxy();
    • }
    Implementation for C++ 11 compilers:
    • // To declare before including glm.hpp, to use the swizzle operators
    • #define GLM_SWIZZLE
    • #include <glm/glm.hpp>
    • void example_cpp11()
    • {
    • glm::vec4 a = glm::vec4(2, 0, 0, 0);
    • glm::vec4 b = glm::vec4(0, 2, 0, 0);
    • glm::vec4 c = glm::vec4((a.zyx() + * 0.5f, 1.0f);
    • // Before being pasted to a function, a swizzle operator needs to be cast into
    • // a vector either explicitly or with the operator ()
    • glm::vec2 d = glm::normalize(glm::vec2(c.yz));
    • // glm::vec2 d = glm::normalize(c.yz()); // Equivalent code
    • a.xyzw = d.xyxy;
    • }

    12/12/2011 - GLM 0.9.3 beta released

    11/11/2011 - GLM 0.9.3 alpha released

    GLM 0.9.3 is making progress which is illustrated by the release of this first alpha.

    • Changelog:
    • Improved doxygen documentation
    • Added new swizzle operators for C++11 compilers
    • Added new swizzle operators declared as functions
    • Added GLSL 4.20 length for vector and matrix types
    • Added GLSL core noise functions
    • Promoted GLM_GTC_noise extension: simplex, perlin, periodic noise functions
    • Promoted GLM_GTC_random extension: linear, gaussian and various random number generation distribution
    • Added GLM_GTX_constants: provides usefull constants
    • Fixed half based type contructors

    24/10/2011 - GLM released

    This revision fixes two problems: First, it adds all matrix products for all possible combinations of none-squared matrices. Thanks to Grant James who has provide the code for that.

    • #include <glm/glm.hpp>
    • void kueken()
    • {
    • glm::mat3x2 m1;
    • glm::mat2x3 n1;
    • ...
    • glm::mat2x2 P = m1 * n1; // Valid before GLM
    • glm::mat3x2 m2;
    • glm::mat4x3 n2;
    • ...
    • glm::mat4x2 P2 = m2 * n2; // Fixed in GLM
    • glm::mat4x3 m3;
    • glm::mat4x4 n3;
    • ...
    • glm::mat4x3 P3 = m3 * n3; // Fixed in GLM
    • ...
    • }

    This support is actually pretty useful as soon as we are interested in optimizing the matrix storage.

    It also fixes vector contructors which can take multiple parameters that may be swizzle operands.

    01/10/2011 - GLM released

    Half based vector types have been fixed on GCC 4.4 and below, missing l-value swizzle operations added and a couple of other bugs squeezed down.

    Finally, all the Visual C++ /W4 warnings should have been removed. However, for this to happen, it is required to build with the Visual C++ language extension disabled (/Za).

    20/09/2011 - GLM released

    This update fixes some major core issues including the implementation of round, floatBitToXint, pack and unpack functions.

    03/09/2011 - GLM released

    Fixed bugs and warnings reported by GLM users. Thanks!

    08/06/2011 - GLM released

    This version only fixes a couple of major bugs introduced in GLM

    02/06/2011 - GLM released

    The main improvement of this version comes from the extended number of matrix constructors so that a programmer can used different scalar types for each parameter.

    • #include <glm/glm.hpp>
    • // Create an identity matrix
    • glm::mat3 m(
    • 1, 0.0, 0,
    • 0.0, 1.0, 0.0f,
    • 0, 0.0, 1.0f);

    The quaternion implementation has been updated as well, fixing the various slerp implementation flavours (mix, shortMix and fastMix) and providing more completeness: Added interaction with GLM_GTX_epsilon and missing lowp_quat, mediump_quat and highp_quat but also none square matrix equivalents.

    Finally, some efforts have been put to remove warnings across all supported compilers.

    24/05/2011 - GLM released

    GLM significantly improves compiler detection which allows CUDA to be automatically recognized when GLM is used inside a CUDA kernel. By conscequence, GLM_FORCE_CUDA is no longer required to be declared.

    It fixed a couple of bugs, including Visual C++ supprot when Visual C++ extensions are disabled and fixed implementations of GLM_GTX_vector_angle and GLM_GTX_rotate_vector extensions.

    09/05/2011 - GLM released

    GLM provides many exciting features which first of all is the CUDA copiler support so that GLM can be used within a CUDA kernel. This is possible only by defining GLM_FORCE_CUDA before including glm/glm.hpp in the CUDA Kernel source code.

    New experimental extensions are also available. GLM_GTX_noise is based on the work by Stefan Gustavson and Ashima Arts on WebGL-noise which adds perlin and simplex noise functions in a pure computational way. If everything goes well, this extension will be promoted to GLM core as implementation of the GLSL noise functions.

    GLM_GTX_ulp provides functions to evaluate the number of ULPs between two floating-point values which gives a way to mesure the accuracy of a function compare to a reference function. In the future, this extension could be used to update the documentation of function and gives the level of accuracy they provide.

    Finally, GLM_GTX_matrix_interpolation is an extension developed by Ghenadii Ursachi to extract axis and angle of a 4 by 4 matrix but also directly interpolate between two matrices. This extension works only on linear transformed matrices.

    Last but not least: with the version 0.9.2, GLM supports CTest to manage GLM test suite which makes tests much easier to maintain. The number of tests have significantly increase, even if a lot more tests are necessary.

    GLM 0.9.2 is not backward compatible with GLM 0.9.1 with only one point: Quaternion SLERP interpolation! In GLM 0.9.1 the function 'mix' always interpolate using the short rotation path but it's no longer the case. The function 'shortMix' has to be called for short path interpolation. 'fastMix' will interpolate two quaternions using a normalized linear quaternion interpolation with non-constant rotation speed.

    07/05/2011 - GLM released

    Various bugs fixed with GLM

    15/04/2011 - GLM released

    17/03/2011 - GLM released

    GLM fixes some bugs, warnings on Clang C++ and clean up a bit the code.

    If you have uncounter any issue with GLM, please download this revision.

    Finally, the work has started for GLM 0.9.2 so if you have requests don't forget to submit them!

    03/03/2011 - GLM final released

    Finally, GLM 0.9.1 branch is reaching the status of stable with GLM

    From GLM 0.9.1 beta, mainly bugs has been fixed. GLM has evolved on many sides since GLM 0.9.0: Improved documentation (manual and doxygen), better test framework, simplified setup/options/configration of GLM and new experimental SIMD API.

    GLM is not 100% backward compatile with GLM but mainly advanced usages should be affected by the differencies. Have a look at the GLM manual for more information on how to use GLM 0.9.1.

    13/02/2011 - GLM and GLM 0.9.1 beta released

    The stable version, GLM, adds the operator * for quaternion products and deprecated the cross function previously used for the same purpose. Also, it clarifies that GLM is a header only library when a user try to build it. Once more, there is nothing to build.

    The development version, GLM 0.9.1 beta, provides an improved API documentation by Alfonse Reinheart, author of a great OpenGL tutorial which uses GLM. This version also improves the SIMD extensions and it fixes many bugs.

    31/01/2011 - GLM 0.9.1 alpha released

    This new version of GLM is bringing a lot of improvements and maybe too many considering the development time it has required: API exposing SIMD implementation but also some new, safe and feature complet swizzling functions and a new setup API. All this is described in the largely updated GLM manual.

    With the new setup system, GLM detects automatically the compiler settings to adapt its implementation to the flag set at build time. It will automatically enable C++0x features, SSE optimizations and the display configuration informations at build-time. The automatic setup can be overdrive by the GLM user.

    The SIMD API maintly focus on vec4 and mat4 implementations that are embodied by the types simdVec4 and simdMat4. The implemention cover most of the common functions, the geometry functions and the matrix functions as described in the GLSL specifications. Because it is hight inefficient to access individual components of a SIMD register, the simdVec4 doesn't allow it. To reflect this constraint, the simdVec4 has to be converted to vec4 first which would be effectively handle by the compiler thank to the function simdCast. Furthermore, GLM provides some specials functions like simdDot4 that returns a simdVec4 instead of a float with the duplicated dot product value in each components and ensure that no unnecessary component manipulations are performed (typically __m128 to float and float to __m128). This implementation can probably be improve in many ways so don't hesitate to send me some feedbacks.

    GLM 0.9.1 is not 100% backward compatible with GLM 0.9.0 but mostly advanced usages should be concerned by this compatibility issues.

    21/12/2010 - GLM released

    GLM is a new update of GLM built over GLM's user bug reports. It mainly fixes issues regarding non-squared matrices but also provides multiple extensions corrections as well.

    I expect to release GLM in Junuary but I might continue to update GLM 0.9.0.X as there are minor incompatibilities.

    01/11/2010 - GLM released

    GLM fixes the usual set of bugs, some allowing a better Clang support.

  • GLM (zip, 2.2 MB)
  • GLM (7z, 1.6 MB)
  • Submit a bug report

  • 04/10/2010 - GLM released

    GLM revision mainly fixes bugs. It also contains a contribution by Arnaud Masserann, a autoexp.dat file to make GLM looks nicer in Visual Studio debugger. To take advantage of this file, edit ${VISUALSTUDIO_DIRECTORY}/common7/packages/debugger/autoexp.dat file and add the content of the file util/autoexp.txt included in GLM

    26/08/2010 - GLM released

    GLM fixes major issues on non-squared matrices.

    08/07/2010 - GLM released

    Second update of GLM 0.9.0 with more bug fixes. It also contains a new extension called GLM_GTX_int_10_10_10_2 to use GLM with OpenGL and GL_ARB_vertex_type_2_10_10_10_rev.

    21/06/2010 - GLM released

    This revision only fixes few extensions bugs.

    25/05/2010 - GLM released

    GLM is finally available! It brings various API changes from GLM 0.8.4.X branch which makes it not backward compatible. GLM is now compatible with Objective C++ to be used for MacOS X and iPhone projects.

    To continue making GLM a better library, 2 mailing lists have been created for users and developers.

    30/04/2010 - GLM 0.9 Beta 2 released

    GLM 0.9 Beta 2 is available and should be the last development release of GLM 0.9.

    The code has been moved from a SVN to Git repository which branching efficiency allowed to remove all the experimental code from this release.

    Various bug fixes and manual updates have been done too.

    03/04/2010 - GLM 0.9 Beta 1 released

    A new development version of GLM 0.9 is available.

    This version is based on GLSL 4.0 and supports the new common and integer functions. Also a long and frequently asked feature has been implemented: inplicit conversions. However, the rules defining implicit conversions by GLSL 4.0 are quite weaked and can't really be apply in C++.

    Reaching the beta status, this new features close the feature list of GLM 0.9. Further development releases may happen before the final release.

    20/02/2010 - GLM 0.9 Alpha 2 released

    This update fixes some problem of Alpha 1 but also brings some improvements in case of errors when using GLM to provide more relevant messages.

    09/02/2010 - GLM 0.9 Alpha 1 released

    First step until a major release for GLM with this first alpha of GLM 0.9.

    This version brings a large internal redesign to improve the library reliability and optimized some parts. It removed the deprecated features and API which implies that GLM 0.9 isn't backward compatible.

    For most users the build issues when upgrading to GLM 0.9 should be reduced especially if they follow the deprecation policy.

    This release is still UNSTABLE and not recommanded for commertial products.

    25/01/2010 - GLM released

    This update just removes some warnings

    By the way, if you have questions about GLM, a good place for those is the Toolkits forum.

    16/11/2009 - GLM released

    This version fixed half scalars and half vectors arithmetics. This is a really slow practice that should be avoid. Half floating point value should be use only to store GPU data. GPUs have native support for half values, not x86 CPUs.

    19/10/2009 - GLM released

    This version is a really minor updates, fixing single issue with half float types.

    05/10/2009 - GLM released

    This version fixes few bugs and provides an major update of the manual thanks to Damian Trebilco.

    16/09/2009 - GLM released

    This new version mainly adds support for Visual Studio 2010 and GCC 4.4. It also provides various code optimization, bug fixes and an extension.

    11/08/2009 - GLM released

    Fixed extension bugs introduced by core update.

    10/08/2009 - GLM released

    Fixed varius bugs. Move determinant fonction to core following GLSL 1.5 specification.

    25/06/2009 - GLM released

    04/06/2009 - GLM released

    Add GLM_GTC_quaternion and GLM_GTC_type_precision extensions both subset of GLM_GTX_quaternion and GLM_GTX_number_precision

    21/05/2009 - GLM released

    The old way to use extensions have been fixed and GLM_GTX_bit extension gets updated with more functions to manipulate bit fields.

    06/05/2009 - GLM released

    This version brings to main changed: Stable extensions and a new extension system.

    The first stable GLM extensions are: GLM_GTC_double_float and GLM_GTC_half_float for higher and lower vectors and matrices floating point precision. GLM_GTC_matrix_operation provides determinant and inverse matrix calculation. GLM_GTC_matrix_transform allows to build scale, rotate and translate matrices and GLM_GTC_matrix_projection provides varius functions to build projection matrices. Few stable extensions yet but the number is going to grow with the next release!

    Both GLM 0.8.2.x extensions use method are deprecated (but still working) and replace by a new one. If you wnat to use GLM_GTC_half_float just include "glm/gtc/half_float.hpp" and it is going to be included in GLM namespace.

    Finally, quite some file have been renamed, using "hpp" instead of ".h". Old file have been deprecated but are still available so that GLM is fully compatible with GLM 0.8.2.x.

    01/04/2009 - GLM released

    13/02/2009 - GLM released

    A new release is available and inogurate a patch number. The goal of this patch number is to release faster fixes from bug reports.

    21/01/2009 - GLM 0.8.2 released

    This release only fixes bugs. Left sided swizzle operators, quaternion operators, vectors access operators for the main onces.

    19/11/2008 - GLM current developments

    Some artifacts have been added to the tracker to give a picture of what you could expect for the next releases.

    If you need something else you can add some artifacts to the tracker. Any comment on added entries is welcome.

    Furthermore, no more release of GLM 0.7.x will be done. Please upgrade to GLM 0.8.1.

    Finally, a pack of programmable oriented OpenGL samples using GLM is under development and planed to be release in December.

    30/10/2008 - GLM 0.8.1 released

    GLM 0.8.1 is released. This new version mainly fixes 64 bit integers with GCC and various bugs.

    23/10/2008 - GLM 0.8.0 final released

    GLM 0.8.0 is released. This new version is now based on GLSL 1.30 specification which provided new functions and precision qualifiers.

    Beyond this, lot of changes have been done to make GLM easier to use, easier to develop, more reliable, more conform to C++ ISO98 standard and GLSL specifications.

    It involves that GLM 0.8.x is not backward compatible with GLM 0.7.x... However, an application port from GLM 0.7.x to GLM 0.8.x isn't a huge work and actually for some, it won’t be work at all.

    On GLM core side, based on GLSL features, vector types can't be automatically cast to pointer anymore for code safety purposes. Vector constructors require a single scalar parameter of the exact number of components.

    On GLM extension side, the mechanism to use them has changed. The old [__]***GTX way doesn't exist anymore. Have a look on the manual for more information.

    Have a look on the manual and the changelog for more information. Don't forget to send your feedback and enjoy!

    22/10/2008 - A Humus demo to feature GLM 0.8.0

    Ambient aperture lighting Humus demo have been updated to use GLM as math library.

    18/10/2008 - Webside updated

    As you can see the website get a little update to prepare GLM 0.8.0 final release.

    GLM 0.8.0 final should be release during the week.

    10/10/2008 - GLM 0.8.0 beta 3 released

    This release fixes some bugs and add few features though extensions. The development is now based on CMake to make easier cross platform tests and project management.

    04/10/2008 - GLM 0.8.0 beta 2 released

    This release mainly improves half float vectors support. By default the low precission vectors are based on float numbers not on half numbers

    It also provides new setup options. GLM_USE_ONLY_XYZW to disable multiple names to access to a single vector component. GLM_USE_ANONYMOUS_UNION to allow multiple component names on half vectors with Visual C++.

    Various bugs and updates of extensions have been done too. Final release is coming...

    26/09/2008 - GLM 0.8.0 beta 1 released

    GLM have been updated to support GLSL 1.30. API documentation had significant improvements to make easier finding of GLSL functions and types.

    GLM 0.8.x is NOT backward compatible with GLM 0.7.x. Upgrade to GLM 0.8.x could involve build errors for the following cases: A lot of improvements have been made to increase the conformance with GLSL specification. Lot of GLSL 1.30 features were already exposed in extensions that have been deleted. The extension syntaxe based on ARB convension is no long used.

    Due to the number of changes GLM 0.8.0 is release as beta first. The final release is schedule for october.

    08/08/2008 - GLM 0.7.6 released

    GLM 0.7.6 provides a better C++ conformance so that you can build GLM with –pedantic G++ parameter or without Visual Studio extensions. To make GLM more reliable, BOOST_STATIC_ASSERT are used according developer wishes.

    05/07/2008 - GLM 0.7.5 released

    GLM 0.7.5 is available and introduces a new build messsage system to get information of GLM build configuration with Visual Studio. This mechanism is documented in section 6 of GLM manual. Also, GLM can be built with GCC pedantic options.

    01/06/2008 - GLM 0.7.4 released

    GLM 0.7.4 introduces a new system to manage external dependencies.

    It allows developing extension using external dependencies like GLEW, Boost, etc. without making required those dependencies for GLM programmer that doesn't need those external dependent extensions.

    The mechanism is described into the updated manual.

    24/05/2008 - GLM 0.7.3 released

    GLM 0.7.3 is released. This version fixes few bugs and add few extensions

    27/04/2008 - GLM 0.7.2 released

    GLM 0.7.2 is released. The documentation have been completed again and several issues handle with precompiler options.

    #define GLM_SWIZZLE GLM_SWIZZLE_FUNC allows to use swizzle operators with internal functions. For example, glm::vec3(1, 2, 3).zyx is replaced by glm::vec3(1, 2, 3)._zyx() with this option.

    #define GLM_FORCE_NO_HALF allows to include all extensions (#include "glm/glmext.h") without any support of half-precision floating-point numbers.

    #define GLM_AUTO_CAST GLM_DISABLE allows to disable automatic cast (eg: glLoadMatrixf(glm::mat4(1.0))) which could involve unfortunate issues in some cases.

    More information on these topic are available in GLM manual section 5 "Known issues".

    24/03/2008 - GLM 0.7.1 released

    GLM 0.7.1 is available under MIT license. It fixes bugs with GCC.

    22/03/2008 - GLM 0.7.0 released

    GLM 0.7.0 is available under MIT license. LGPL lisence have been discard due to an issue of use for console development. This release contains a lot better documentation based on Doxygen. Lot of bugs have been fixed and the documentation completed. Thanks to all people that has contributed thought bug reports and ideas to make this version a lot better!

    10/12/2007 - GLM 0.6.4 released

    GLM 0.6.4 is available and fixes some swizzle operator issues.

    05/11/2007 - GLM 0.6.3 released

    GLM 0.6.3 fixes accesses of matrices and a 3DSMax SDK conflict.

    08/10/2007 - GLM 0.6.2 released

    GLM 0.6.2 fixes an error on an extension.

    07/10/2007 - GLM 0.6.1 released

    GLM 0.6.1 is a minor update that fix an issue on extension namespace and add two more extensions.

    16/09/2007 - GLM 0.6.0 released

    GLM 0.6.0 is available. For this release, work focus on extensions. A new mecanisum allows to integrate GLM extensions as it is actually done for GLSL extension by vendors. Lot of new extensions have been added.

    19/02/2007 - GLM 0.5.1 released

    This release fixes some issues with swizzle operators.

    26/01/2007 - Cattmull Clark subdivision sample

    A new sample is available. It's an update of Philip Rideout's Catmull Clark subdivision program that uses GLM. Released with pleasant permission of Philip Rideout.

    06/01/2007 - GLM 0.5.0 released

    This release include GLSL 1.2 new feature in the core implementation. Also, it includes swizzle read and write operators and a custom options system to setup GLM.

    It includes some new extensions to extend GLSL features but they remain experimental. The next release should provide the first stable extensions.

    The GLM 0.5.0 packages contain some basic samples and some documentation. The ray tracer sample has been updated to GLM 0.5.0. Except for specific cases, especially with extensions, GLM 0.5 is backward compatible.

    Now, GLM development is taking advantages of services: a bug tracker system and the development source code is publicly available on SVN server.

    22/05/2006 - GLM 0.4.1 released

    A GLM update is available. It simply includes some examples for a sweet start with GLM.

    The examples show how to use GLM with OpenGL intermediate mode and OpenGL vertex arrays. Also, they show how to use GLM extensions to replace GLU and OpenGL function witch could slightly increase performances by decreasing the number of OpenGL states changes.

    17/05/2006 - GLM 0.4.0 released

    This release introduces first GLSL 1.2 features as planed. Also, various new extensions have been added and updated. Finally, it's not anymore required to include windows.h before glm.h when windows.h is required.

    The number of features of GLM, including extensions, start to really increase the compilation time. That's why it's recommended to use precompiled headers.

    23/04/2006 - Roadmap for the years

    Version 0.4 will complete matrices and vectors operators and will add GLSL 1.2 features. First, conversions simplifications will be integrated. Then, 4 per 3 matrices and outer product will be available from extensions. The transpose function is already available from extension.

    Version 0.5 will integrate GLSL 1.2 features to GLM core.

    Version 0.6 will add swizzle operators in reading and writing. (eg: vec3 v1(1.0, 2.0, 3.0); vec3 v2 =; v1.zyx = v;).

    22/04/2006 - GLM 0.3.2 released

    This release corrects two main bugs. First, a bug of the imat4 and mat4 division operators and other correct the vectors components access from texture coordinate way.

    28/03/2006 - GLM 0.3.1 released

    This update adds GCC 4.0 support for MacOS X and Linux and GCC 4.1 under Linux. Also, its provides some optimisations.

    Further release will prodive GLSL 1.2 compliances.

    19/02/2006 - GLM 0.3 released

    A new release of GLM is now available. It improves GLSL data type conversion and construction compliance. Also, It's adds extensions like some to manage double-precision and half-precision float numbers. Finally a Doxygen documentation has been added.

    This new release have been tested under Visual C++ 7.1, Visual C++ 8.0, GCC 3.2.3 et GCC 3.4.2.

    06/05/2005 - GLM 0.2 released

    A new release of GLM is available. A few bugs have been fixed, the portability of GLSL into C++ has been improved, and new experimental extensions have been implemented, enhancing GLSL features.

    The project supports quaternions, adds new features to handle colors, vectors and matrices. For example, GLM allows base colors changing, vector projected operations, and 2D/3D transforms.

    To demo the features of this new version, a sample program is included. It is a simple Ray Tracer supporting reflected and refracted rays, three lights types (point, directionnal and spot), two objects types (sphere, plan), using all of the GLM possibilities.

    04/05/2005 - English pages

    The english section of this site is now available.

    21/02/2005 - GLM 0.1 is available

    This is the first public availability of GLM. This library supports a part of GLSL specification: All vector, matrice types, the operators and associated functions.

    For now, there isn't a detailed documentation, but you can have a look on GLSL specifications. Consider any mismatch between GLSL and GLM as a bug. Keep in mind the library is included in the namespace "glm".

    This project is multi-platform and was successfully tested under Visual C++ 7.1, MinGW 3.4 and GCC 3.4.