Including the source files / project file

The simpler but less flexible way is to include glew.h and glew.c into your project and define the GLEW_STATIC preprocessor constant for the static library or executable you are building together with GLEW. You also need to replace <GL/gl.h> and <GL/glu.h> with <glew.h> and set the appropriate include flag (-I) to tell the compiler where to look for it. For example:

#include <glew.h>
#include <GL/glut.h>
<gl, glu, and glut functionality is available here>

On Windows you can also add the supplied project file (glew.dsp or glew.vcproj) to your workspace or solution and compile it together with your other projects. In this case you need to change the GLEW_BUILD preprocessor constant to GLEW_STATIC, otherwise you get build errors. Note that GLEW does not use the C runtime library, so it does not matter which version (single-threaded, multi-threaded or multi-threaded DLL) it is linked with.

Using GLEW as a shared library

Alternatively, you can use the provided project files / makefile to build a separate shared library you can link your projects with later. In this case the best practice is to install glew.h, glew32.lib, and glew32.dll / libGLEW.so to where the OpenGL equivalents gl.h, opengl32.lib, and opengl32.dll / libGL.so are located. Note that you need administrative privileges to do this. If you do not have administrator access and your system administrator will not do it for you, you can install GLEW into your own lib and include subdirectories and tell the compiler where to find it. Then you can just replace <GL/gl.h> with <GL/glew.h> in your program:

#include <GL/glew.h>
#include <GL/glut.h>
<gl, glu, and glut functionality is available here>

#include <GL/glew.h>
<gl and glu functionality is available here>

Don't forget to link your project with glew32.lib, glu32.lib, and opengl32.lib on Windows and libGLEW.so, libGLU.so, and libGL.so on Linux (-lGLEW -lGLU -lGL).

It is important to keep in mind that glew.h includes neither windows.h nor gl.h. Also, GLEW will warn you by issuing a preprocessor error in case you have included gl.h, glext.h, or glATI.h before glew.h.

To install the shared library version of GLEW you need to copy the headers and libraries into their destination directories. On Windows this boils down to copying (no, we will not write a Windows installer for you).

where {VC Root} is your Visual C++ directory, typically C:/Program Files/Microsoft Visual Studio/VC98 for Visual Studio 6.0 or C:/Program Files/Microsoft Visual Studio/Vc7/PlatformSDK for Visual Studio .NET. However, if you build GLEW with Visual Studio .NET, the project file will automatically install it into these directories, so you don't have to worry about installation at all.

On Linux, typing "make install" will attempt to install GLEW into /usr/include/GL and /usr/lib. You can customize the installation target via the GLEW_TARGET environment variable if you do not have write access to these directories.

First you need to create a valid OpenGL rendering context and call glewInit() to initialize the extension entry points. If glewInit() returns GLEW_OK the initialization succeeded and you can use the available extensions as well as core OpenGL functionality. For example:

#include <GL/glew.h>
#include <GL/glut.h>
...
glutInit(&argc, argv);
glutCreateWindow("GLEW Test");
int err = glewInit();
if (GLEW_OK != err)
{
  /* problem: glewInit failed, something is seriously wrong */
  fprintf(stderr, "Error: %s\n", glewGetErrorString(err));
  ...
}

Querying the available OpenGL extensions

To find out if a particular extension is available on your platform, use the globally defined structure glew:

if (glew.ARB_vertex_program)
{
  /* it is safe to use the ARB_vertex_program extension here */
  glGenProgramsARB(...);
}

if (glew.GL_13)
{
  /* Yay! OpenGL 1.3 is supported! */
}

if (GL_TRUE == glewGetExtension("GL_ARB_fragment_program"))
{
  /* Looks like ARB_fragment_program is supported. */
}

Experimental drivers

GLEW works by querying the supported extensions from the graphics driver. Experimental drivers, however, might not report every available extension through the standard mechanism, in which case GLEW will report it unsupported. To circumvent this situation, the glewExperimental global switch can be turned on by setting it to GL_TRUE before calling glewInit(). This makes sure that all extensions with valid entry points will be exposed.

Platform specific extensions

Platform specific extensions are separated into two header files: wglew.h and glxew.h. These files define the available WGL and GLX extensions as well as the global wglew and glxew structs, which work similarly to the glew structure. To determine if a given WGL or GLX extension is supported, query wglew.{extension name} or glxew.{extension_name}. For example:

#include <GL/wglew.h>

if (wglew.ARB_pbuffer)
{
  /* OK, we can use pbuffers */
}
else
{
  /* Sorry, pbuffers will not work on this platform */
}

wglinfo: reporting extensions and visuals on Windows

wglinfo is the Windows version of glxinfo. By default it creates a file called wglinfo.txt containing a list of available OpenGL, WGL, and GLU extensions as well as a table of visuals, aka. pixelformats. PBuffer and multiple output capable visuals are also included. The format of the table is described here. For additional usage information, type wglinfo -h.

glewinfo: extension verification utility

glewinfo allows you to verify the entry points for the extensions supported on your platform. It uses GLEW to find out which extensions and entry points are available and reports the results to a text file called glewinfo.txt.

Note that according to the WGL documentation you have to initialize the entry points for every rendering context you create. GLEW ignores this requirement, and does not define per context entry points. This means that you need to call glewInit() only once in your program, or more precisely once per process. We have not noticed any problems so far from ignoring the specification.

GLEW is derived from the EXTGL project by Lev Povalahev. It is licensed under the LGPL, the BSD license, the SGI Free Software License B, and the GLX Public License. We encourage those who are not in favor of the LGPL to read this excellent tutorial.