glad

Parses official Khronos XML specifications (OpenGL, Vulkan, EGL, GLX, WGL) into an in-memory object model representing types, commands, enumerations, and extensions. Uses a Specification class that organizes parsed data into FeatureSets, enabling selective inclusion of API versions, profiles (core/compatibility), and individual extensions. The parser builds a complete dependency graph of API features, allowing downstream generators to understand which functions depend on which types and extensions.

Generates language-specific loader code (C, C++, Rust, D, Nim, Pascal) using a plugin-based architecture where each language has a BaseGenerator subclass that processes Jinja2 templates. The JinjaGenerator class provides template rendering with access to the parsed specification's types, commands, and extensions. Language-specific generators can override template paths and add custom filters/globals to handle language idioms (e.g., Rust's unsafe blocks, C's function pointers).

Generates loader code that defers function pointer resolution until first use rather than loading all functions at initialization time. When a function is called for the first time, the loader checks if the function pointer is NULL and loads it on-demand using the platform-specific resolution mechanism. This reduces initialization time and memory usage for applications that only use a subset of available functions. Implemented via optional wrapper macros or inline functions that check and load function pointers.

Provides a declarative API for selecting specific graphics API versions (e.g., OpenGL 3.3, Vulkan 1.2) and profiles (core, compatibility, es) with automatic dependency resolution. When a developer specifies 'OpenGL 3.3 core', GLAD automatically includes all types and functions required by that version and profile, resolving dependencies on lower API versions. The selection mechanism prevents invalid combinations (e.g., core profile with deprecated functions) and provides clear error messages when incompatible selections are made.

Generates loader code that dynamically resolves graphics API functions at runtime using platform-specific mechanisms: wglGetProcAddress on Windows, glXGetProcAddress on Linux/X11, and dlopen/dlsym on Unix-like systems. The generated loader provides a consistent cross-platform interface that abstracts these platform differences. Supports both eager loading (all functions loaded at initialization) and lazy loading (functions loaded on first use), with optional debug mode that logs which functions failed to load.

Generates loader code that supports multiple simultaneous graphics API contexts (e.g., multiple OpenGL contexts or Vulkan devices) by storing function pointers in context-specific structures rather than global variables. The generated code provides context-aware function dispatch mechanisms, allowing applications to switch between contexts and have the correct function pointers automatically used. This is particularly important for Vulkan (which is inherently multi-device) and for OpenGL applications using multiple rendering contexts.

Generates loader code that queries the graphics API at runtime to determine which extensions are available on the user's GPU/driver, then selectively loads only those extension functions. The generated code provides boolean flags (e.g., GLAD_GL_ARB_multisample) indicating whether each extension is available, allowing applications to conditionally use advanced features. This is implemented via glGetString(GL_EXTENSIONS) for OpenGL or vkEnumerateInstanceExtensionProperties for Vulkan.

Provides CMake functions and modules that invoke GLAD during the build process, generating loader code as part of the project's build pipeline. The integration allows developers to specify API requirements (e.g., OpenGL 3.3 core) in CMakeLists.txt, and GLAD automatically generates the appropriate loader code and adds it to the build. This eliminates the need to pre-generate and commit loader code to version control.

Packages GLAD as a Python module installable via pip, allowing developers to invoke GLAD programmatically from Python code or the command line. The package includes all specifications, templates, and generators, making it self-contained and easy to integrate into Python-based build systems or scripts. Developers can import glad and call generation functions directly, or use the command-line interface via python -m glad.

Handles function name aliases and mappings that occur when graphics APIs evolve — for example, glClearDepth (OpenGL 1.0) was renamed to glClearDepthf in OpenGL ES. The generator tracks these aliases and can generate code that maps old function names to new implementations or provides both names pointing to the same function pointer. This enables applications to use either the old or new function name depending on their compatibility requirements.

Generates code that follows language-specific idioms and conventions for each supported language (C, C++, Rust, D, Nim, Pascal). For example, Rust generation wraps unsafe function calls in unsafe blocks, C++ generation uses namespaces, and D generation uses D-specific calling conventions. Each language has its own template directory and generator subclass that can customize how types, functions, and extensions are represented in the target language.

Generates loader code that optionally logs all graphics API function calls and tracks which functions failed to load at initialization time. When debug mode is enabled, the generated code wraps each function call with logging statements that record the function name, arguments (if available), and return value. Failed function loads are tracked and reported, helping developers identify missing extensions or driver incompatibilities. This is implemented via optional wrapper functions or macros that intercept function calls.