Skip to content


Switch branches/tags

Latest commit

* Make the workflow a bit more reliable

This makes a few changes.
Most importantly, it fixes the installtion of deps.
This was due to the repo list not being updated and partly because apt-get
is a terrible package manager (in my opinion) and thus doesn't do it automatically.

The tests now only run for the oldest and newest Go versions only as if it works on both of those,
we can litterally say that anything between is a bug in Go and not here. Apart from that, it
is mostly some cleanups and updates to the used actions.

* Remove a newline

Git stats


Failed to load latest commit information.

gl Build Status Go Reference

This repository holds Go bindings to various OpenGL versions. They are auto-generated using Glow.


  • Go functions that mirror the C specification using Go types.
  • Support for multiple OpenGL APIs (GL/GLES/EGL/WGL/GLX/EGL), versions, and profiles.
  • Support for extensions (including debug callbacks).


  • A cgo compiler (typically gcc).
  • On Ubuntu/Debian-based systems, the libgl1-mesa-dev package.


Use go get -u to download and install the prebuilt packages. The prebuilt packages support OpenGL versions 2.1, 3.1, 3.2, 3.3, 4.1, 4.2, 4.3, 4.4, 4.5, 4.6 across both the core and compatibility profiles and include all extensions. Pick whichever one(s) you need:

go get -u{3.2,3.3,4.1,4.2,4.3,4.4,4.5,4.6}-{core,compatibility}/gl
go get -u
go get -u

Once the bindings are installed you can use them with the appropriate import statements.

package main

import ""

func main() {
	window := ... // Open a window.

	// Important! Call gl.Init only under the presence of an active OpenGL context,
	// i.e., after MakeContextCurrent.
	if err := gl.Init(); err != nil {

The gl package contains the OpenGL functions and enumeration values for the imported version. It also contains helper functions for working with the API. Of note is gl.Ptr which takes a Go array or slice or pointer and returns a corresponding uintptr to use with functions expecting data pointers. Also of note is gl.Str which takes a null-terminated Go string and returns a corresponding *int8 to use with functions expecting character pointers.

A note about threading and goroutines. The bindings do not expose a mechanism to make an OpenGL context current on a different thread so you must restrict your usage to the thread on which you called gl.Init(). To do so you should use LockOSThread.


Examples illustrating how to use the bindings are available in the example repo. There are examples for OpenGL 4.1 core and OpenGL 2.1.

Function Loading

The procaddr package contains platform-specific functions for loading OpenGL functions. Calling gl.Init() uses the auto subpackage to automatically select an appropriate implementation based on the build environment. If you want to select a specific implementation you can use the noauto build tag and the gl.InitWithProcAddrFunc initialization function.

Go >=1.14 and checkptr

In version 1.14 of Go, the race detector added checkptr instrumentation. This compilation option ensures that programs follow unsafe.Pointer safety rules. See here for details:

If enabled, there is a high chance that it will cause program termination when calling specific OpenGL functions, with a message like this:

fatal error: checkptr: pointer arithmetic computed bad pointer value

The reported call stack will point to a function like gl.VertexAttribPointer() that receives an unsafe.Pointer as parameter. In case such function requires an "offset" passed in as a pointer (in the low-level API), a different signature needs to be used in order to satisfy the detector.

For this purpose glow generates "override" functions which have a different signature, taking uintptr instead. These functions have the suffix WithOffset (or similar) in their name. For the previous example, it would be gl.VertexAttribPointerWithOffset().

Not all such functions have an appropriate override! In case you stumble over such an error, and the override is missing, you have the following options:

  • Disable the detector by building your program with -gcflags=all=-d=checkptr=0
  • Report the missing function(s) as issue for glow
  • Possibly even create a pull-request for glow with the missing override yourself, and re-generate the gl bindings.


These gl bindings are generated using the Glow generator. Only developers of this repository need to do this step.

It is required to have glow source in a sibling directory to go-gl/gl since relative paths are used for generation (see generate.go). For non-module-aware cases, this means glow needs to be in the same Go workspace as go-gl/gl. For module-aware cases, go-gl/glow needs to be checked out parallel to go-gl/gl.

In either case, the glow binary must be in your $PATH. Doable with go get -u if your $GOPATH/bin is in your $PATH.

Perform generation with the following:

cd path/to/go-gl/gl
go generate -tags=gen .

More information about these bindings can be found in the Glow repository.


Go bindings for OpenGL (generated via glow)







No releases published


No packages published