glcontext

3.0.0 · active · verified Tue Apr 14

glcontext is a Python library providing portable headless OpenGL context creation, making it possible to run OpenGL applications without a display server or window. It supports various backends like standalone, EGL, OSMesa, WGL, and GLX. The current version is 3.0.0, with a release cadence tied to the moderngl ecosystem and bug fixes.

Warnings

breaking The `glcontext.headless_context` function was removed and replaced by `glcontext.create_context`. To create a standalone headless context, use `create_context(standalone=True)`.
Fix: Replace calls to `glcontext.headless_context()` with `glcontext.create_context(standalone=True)`.
gotcha Context creation can fail if the required OpenGL drivers or backend libraries (e.g., EGL, OSMesa, GLX) are not available or correctly configured on the system. Error messages can sometimes be generic or misleading.
Fix: Ensure your system has the necessary OpenGL drivers and libraries (e.g., Mesa for `osmesa`, appropriate vendor drivers for `egl`/`glx`) installed and accessible. Check `glcontext.available` for supported backends before attempting to create a context.
gotcha Not explicitly releasing OpenGL contexts can lead to resource leaks, especially in applications that create and destroy many contexts or run for extended periods.
Fix: Always call `ctx.release()` on the `Context` object when you are finished with it to free up underlying system resources.

Install

pip install glcontext Install latest version

Imports

create_context
```
from glcontext import create_context
```
`headless_context` was removed and renamed to `create_context` in version 3.0.0. The `standalone` argument is now used to specify a standalone context.

Quickstart

This example demonstrates how to create a basic headless OpenGL context using the `create_context` function and the `standalone=True` argument. It also shows how to retrieve basic context information and correctly release resources.

import glcontext

# Create a headless OpenGL context using the standalone backend.
# This is the recommended way for most headless environments.
# Other backends like 'egl', 'osmesa', 'wgl', 'glx' can be specified
# via the 'backend' argument, e.g., create_context(backend='egl')
try:
    ctx = glcontext.create_context(standalone=True)
    print(f"Successfully created glcontext: {ctx}")
    print(f"OpenGL Version: {ctx.version_string}")
    # The context is now available for OpenGL operations.
    # For example, if using with moderngl:
    # ctx.make_current()
    # import moderngl
    # mgl_ctx = moderngl.create_context(require=ctx.version_code)
    # print(f"ModernGL context created with version: {mgl_ctx.version_code}")
    ctx.release() # Release the context when done
except Exception as e:
    print(f"Failed to create glcontext: {e}")
    print("Ensure appropriate OpenGL drivers or Mesa libraries are installed for headless operation.")

view raw JSON →