OpenGL Loading Library

Jump to: navigation, search

An OpenGL Loading Library is a library that loads pointers to OpenGL functions at runtime, core as well as extensions. This is required to access functions from OpenGL versions above 1.1 on most platforms. Extension loading libraries also abstracts away the difference between the loading mechanisms on different platforms.

Most extension loading libraries override the need to include gl.h at all. Instead, they provide their own header that must be used. Most extension loading libraries use code generation to construct the code that loads the function pointers and the included headers. Information is available if you wish to perform this manually, but you are encouraged to use one of these libraries yourself.


The OpenGL Extension Wrangler library provides access to all GL entrypoints. It supports Windows, MacOS X, Linux, and FreeBSD.

GLEW has a problem with core contexts. It calls glGetString(GL_EXTENSIONS), which causes GL_INVALID_ENUM​ on GL 3.2+ core context as soon as glewInit()​ is called. It also doesn't fetch the function pointers. The solution is for GLEW to use glGetStringi instead. The current version of GLEW is 1.10.0 but they still haven't corrected it. The only fix is to use glewExperimental​ for now:

  GLenum err=glewInit();
    //Problem: glewInit failed, something is seriously wrong.
    cout<<"glewInit failed, aborting."<<endl;

glewExperimental​ is a variable that is already defined by GLEW. You must set it to GL_TRUE before calling glewInit()​.

You might still get GL_INVALID_ENUM (depending on the version of GLEW you use), but at least GLEW ignores glGetString(GL_EXTENSIONS) and gets all function pointers.

If you are creating a GL context the old way or if you are creating a backward compatible context for GL 3.2+, then you don't need glewExperimental.

As with most other loaders, you should not include gl.h​, glext.h​, or any other gl related header file before glew.h​, otherwise you'll get an error message that you have included gl.h​ before glew.h​. You shouldn't be including gl.h​ at all; glew.h​ replaces it.

GLEW also provides wglew.h​ which provides Windows specific GL functions (wgl functions). If you include wglext.h​ before wglew.h​, GLEW will complain. GLEW also provides glxew.h​ for X windows systems. If you include glxext.h​ before glxew.h​, GLEW will complain.


The GL3W library focuses on the core profile of OpenGL 3 and 4. It only loads the core entrypoints for these OpenGL versions. It supports Windows, Linux, and FreeBSD.

Note: GL3W does not load extension functions. It is for core OpenGL only; you have to manually load extension functions.

GL3W relies on Python 2.6 for its code generation. Unlike other extension loaders, GL3W actually does the code generation on your machine. This is based on downloading and parsing the glcorearb.h​ file from the OpenGL Registry website.

On the one hand, this means that it is always up-to-date, more or less. On the other hand, this also makes it beholden to the format of glcorearb.h​ (which has no true format), as well as requiring that the user of GL3W have a Python 2.6 installation.

GL3W is used like this:

//****Create a GL 3.x or GL 4.x core context
//****Make the context current (for example, on Windows you need to call wglMakeCurrent())
//****Now let's have GL3W get the GL function pointers
GLint GLMajorVer, GLMinorVer;
  cout<<"GL3W failed to get GL function pointers."<<endl;
glGetIntegerv(GL_MAJOR_VERSION, &GLMajorVer);
glGetIntegerv(GL_MINOR_VERSION, &GLMinorVer);

OpenGL Loader Generator

The OpenGL Loader Generator This tool is similar to GL3W in several respects. It generates GL loaders, rather than being a library you download and compile. The difference is that it is less specialized; GL3W will only generate core OpenGL functions/enumerators, so no extensions. And it only does so for the most recent version of OpenGL (currently 4.4).

The GL Loader Generator is much more generalized. You can generate a header/source pair for any version of OpenGL, from 1.1 to 4.4. You can include whichever OpenGL extensions you so desire extensions or none at all. And it has the ability to generate source code in a variety of styles, from the standard C-style that most users are familiar with, to C++ functions/enums wrapped in namespaces, and so forth. The system is also user-extensible.

Also, unlike GL3W, it works for WGL and GLX extensions too. So you can generate headers for the platform-specific APIs.

Like GL3W, the loader generator is built in a scripting language. Unlike GL3W, this tool is written in Lua, which is downloadable for a variety of platforms (and has a much smaller install package than Python, if you care about that sort of thing).

The tool is fairly simple to use, and its use is specified in some detail on the website, with several examples.

Unofficial OpenGL SDK

The Unofficial OpenGL SDK comes with a component for loading OpenGL functions. This component, called GL Load, has a C and C++ interface for loading OpenGL functions. It also provides different headers for different OpenGL versions. It even has headers that remove compatibility enums and functions for versions of OpenGL 3.1 or greater.

Here is a code example:

#include <glload/gl_3_3.h> //OpenGL version 3.3, core profile. C-style functions.
#include <glload/gll.h>    //The C-style loading interface.
//Include headers for FreeGLUT/GLFW/other GL tools.
int main(int argc, char *argv[])
  //Initialize OpenGL and bind the context
  if(LoadFunctions() == LS_LOAD_FAILED)
    //exit in some way
  //Loading succeeded. Now use OpenGL functions.
  //Do OpenGL stuff.
  GLuint vertShader = glCreateShader(GL_VERTEX_SHADER);
  GLuint fragShader = glCreateShader(GL_FRAGMENT_SHADER);

GL Load even offers special headers for C++ code, that moves as much of OpenGL as possible into a namespace. The equivalent code in the C++ interface is as follows:

#include <glload/gl_3_3.hpp> //OpenGL version 3.3, core profile. C++-style functions.
#include <glload/gll.hpp>    //The C-style loading interface.
//Include headers for FreeGLUT/GLFW/other GL tools.
int main(int argc, char *argv[])
  //Initialize OpenGL and bind the context
  if(glload::LoadFunctions() == glload::LS_LOAD_FAILED)
    //exit in some way
  //Loading succeeded. Now use OpenGL functions.
  //Do OpenGL stuff.
  GLuint vertShader = gl::CreateShader(gl::GL_VERTEX_SHADER);
  GLuint fragShader = gl::CreateShader(gl::GL_FRAGMENT_SHADER);

glbinding (C++ binding)

glbinding is a new, generated, cross-platform C++ binding for OpenGL which is solely based on the new xml-based OpenGL API specification (gl.xml). It leverages modern C++11 features like enum classes, lambdas, and variadic templates, instead of relying on macros (all OpenGL symbols are real functions and variables). It provides type-safe parameters, per feature API header, lazy function resolution, multi-context and multi-thread support, global function callbacks, meta information about the generated OpenGL binding and the OpenGL runtime, as well as multiple examples for quick-starting your projects.

Current gl code, written with a typical C binding for OpenGL is fully compatible for the use with glbinding:

#include <glbinding/gl/gl.h>
#include <glbinding/Binding.h>
using namespace gl;
int main()
  // create context, e.g. using GLFW, Qt, SDL, GLUT, ...
  // ...

glbinding also supports OpenGL feature (version) specific symbols for functions, enums, and bitfields. For example:

  • functions32.h provides all OpenGL commands available up to 3.2 in namespace gl32.
  • functions32core.h provides all non-deprecated OpenGL commands available up to 3.2 in namespace gl32core.
  • functions32ext.h provides all OpenGL commands specified either in 3.3 and above, or by extension in gl32ext.

More details and examples can be found on the github project page and examples wiki respectively.


The project seems more or less defunct.

While there is activity in the Git repository on Sourceforge, there has not been a new official version and distribution in years. The recent activity could represent a project coming back, but currently you would be better advised to look elsewhere for an OpenGL loader.