OpenGL Backends

Relevant source files

• backends/imgui_impl_allegro5.h
• backends/imgui_impl_dx10.cpp
• backends/imgui_impl_dx10.h
• backends/imgui_impl_dx11.cpp
• backends/imgui_impl_dx11.h
• backends/imgui_impl_dx12.cpp
• backends/imgui_impl_dx12.h
• backends/imgui_impl_dx9.cpp
• backends/imgui_impl_dx9.h
• backends/imgui_impl_metal.h
• backends/imgui_impl_metal.mm
• backends/imgui_impl_opengl2.cpp
• backends/imgui_impl_opengl2.h
• backends/imgui_impl_opengl3.cpp
• backends/imgui_impl_opengl3.h
• backends/imgui_impl_opengl3_loader.h
• backends/imgui_impl_sdlgpu3.cpp
• backends/imgui_impl_sdlgpu3.h
• backends/imgui_impl_vulkan.cpp
• backends/imgui_impl_wgpu.cpp

This page documents Dear ImGui's OpenGL renderer backends, which translate ImGui draw commands into OpenGL API calls. These backends handle shader compilation, buffer management, texture uploads, and render state configuration for OpenGL-based rendering.

For information about platform backends (GLFW, SDL, Win32, etc.) that work alongside these renderer backends, see Platform Backends. For other renderer backends (Vulkan, DirectX, Metal, etc.), see Renderer Backends.

Overview and Backend Selection

Dear ImGui provides two OpenGL renderer backends:

Backend	File	Use Case	GL Versions	Pipeline
OpenGL 3	imgui_impl_opengl3.cpp/h	Modern applications	Desktop: 2.x, 3.x, 4.x ES: 2.0, 3.0 WebGL: 1.0, 2.0	Programmable (shaders)
OpenGL 2	imgui_impl_opengl2.cpp/h	Legacy/reference	Desktop: 1.x, 2.x	Fixed-function

Recommendation: Use imgui_impl_opengl3 for all new projects. The OpenGL 2 backend is provided primarily as a reference implementation and for very old systems that cannot support shaders.

Key Features:

• ImGuiBackendFlags_RendererHasVtxOffset: Large mesh support (64k+ vertices) - Desktop GL 3.2+ only
• ImGuiBackendFlags_RendererHasTextures: Dynamic font atlas texture updates
• User texture binding via GLuint texture identifiers

Sources: backends/imgui_impl_opengl3.cpp1-119 backends/imgui_impl_opengl2.cpp1-49

OpenGL 3 Backend Architecture

Backend Data Structure

ImGui_ImplOpenGL3_Data stores all backend state including:

• GL version detection: Runtime GL version and profile detection
• Shader handles: Compiled vertex/fragment shaders with attribute/uniform locations
• Buffer objects: Vertex and index buffers with dynamic sizing
• Capability flags: Feature detection (polygon mode, sampler binding, clip origin)

Sources: backends/imgui_impl_opengl3.cpp232-257

Initialization and GL Loader

Initialization Process:

1. GL Loader: The backend includes an embedded minimal GL loader (imgui_impl_opengl3_loader.h) to avoid external dependencies. This is automatically used unless you define IMGUI_IMPL_OPENGL_LOADER_CUSTOM.

2. Version Detection: The backend detects GL version and profile at runtime:

   • Desktop GL 2.x: Falls back to parsing GL_VERSION string
   • Desktop GL 3.0+: Uses glGetIntegerv(GL_MAJOR_VERSION/GL_MINOR_VERSION)
   • OpenGL ES: Detected via version string or compile-time defines

3. GLSL Version: You can specify the GLSL version string or let the backend choose defaults:

   • Desktop: "#version 130" (or "#version 150" on macOS)
   • ES 2.0: "#version 100" (WebGL 1.0)
   • ES 3.0: "#version 300 es" (WebGL 2.0)

Example Initialization:

Sources: backends/imgui_impl_opengl3.cpp314-427 backends/imgui_impl_opengl3.cpp291-311

GLSL Version Configuration

The following table shows the correspondence between OpenGL and GLSL versions:

OpenGL Version	GLSL Version	String
2.0	110	"#version 110"
2.1	120	"#version 120"
3.0	130	"#version 130"
3.1	140	"#version 140"
3.2	150	"#version 150"
3.3	330	"#version 330 core"
4.0+	400+	"#version 400 core"
ES 2.0	100	"#version 100"
ES 3.0	300	"#version 300 es"

Compile-Time Defines:

• IMGUI_IMPL_OPENGL_ES2: Force OpenGL ES 2.0 mode (auto-detected on iOS/Android/Emscripten)
• IMGUI_IMPL_OPENGL_ES3: Force OpenGL ES 3.0 mode
• IMGUI_IMPL_OPENGL_LOADER_CUSTOM: Disable embedded GL loader

Sources: backends/imgui_impl_opengl3.cpp102-118 backends/imgui_impl_opengl3.cpp386-400

Shader Implementation

The shaders are simple and perform:

• Vertex shader: Orthographic projection transformation, pass-through of UV and color
• Fragment shader: Texture sampling multiplied by vertex color

Shaders are compiled at device object creation time with appropriate version strings and precision qualifiers for ES contexts.

Sources: backends/imgui_impl_opengl3.cpp601-715

Rendering Pipeline

Key Rendering Steps:

1. Texture Updates: Process pending texture updates from draw_data->Textures list
2. Buffer Management: Dynamically grow vertex/index buffers if needed
3. State Setup: Configure blend modes, depth testing, scissor testing, viewport
4. Draw Commands: Iterate through draw lists and issue draw calls
5. State Restore: Restore all modified GL state (viewport, scissor, blend, textures, etc.)

Sources: backends/imgui_impl_opengl3.cpp535-785

State Management

The backend saves and restores extensive GL state to avoid interfering with the application:

State Backup & Restore:

• Blend: blend equation, blend func, blend func separate
• Culling: cull face mode
• Depth: depth test, depth func
• Scissor: scissor test, scissor rect
• Viewport: viewport rect
• Polygon mode (Desktop GL only)
• Primitive restart (Desktop GL 3.1+)
• Clip origin (Desktop GL 4.5+)
• Texture binding: active texture unit, texture bindings
• Sampler binding (GL 3.3+)
• Buffers: array buffer, element array buffer, pixel unpack buffer
• Vertex array: VAO binding (or vertex attribute state for ES 2.0)
• Shader: current program

Sources: backends/imgui_impl_opengl3.cpp787-984

Texture Management

Texture Update Process:

1. ImGui_ImplOpenGL3_UpdateTexture() is called during RenderDrawData() for textures with non-OK status
2. Creation: Allocates GL texture, uploads RGBA32 data with glTexImage2D
3. Updates: Uses glTexSubImage2D for partial updates
4. Destruction: Calls glDeleteTextures and clears texture ID
5. Sampling: Linear filtering with clamp-to-edge addressing (changed from repeat in v1.92+)

Pixel Store State: The backend sets GL_UNPACK_ALIGNMENT to 1 before texture operations to handle tightly packed RGBA data.

Sources: backends/imgui_impl_opengl3.cpp987-1094

Buffer Management

The backend uses dynamic vertex and index buffers that grow as needed:

Buffer Sizing Strategy:

• Initial vertex buffer: 5000 vertices
• Initial index buffer: 10000 indices
• Growth: TotalVtxCount + 5000 / TotalIdxCount + 10000
• Usage: GL_STREAM_DRAW (data changes every frame)

Vertex Format (ImDrawVert):

Attribute 0 (aPos):   2 floats at offset 0
Attribute 1 (aUV):    2 floats at offset 8
Attribute 2 (aColor): 4 ubytes at offset 16 (normalized)

Large Mesh Support: Desktop GL 3.2+ supports ImGuiBackendFlags_RendererHasVtxOffset via glDrawElementsBaseVertex(), allowing meshes with 64k+ vertices even with 16-bit indices.

Sources: backends/imgui_impl_opengl3.cpp1096-1166 backends/imgui_impl_opengl3.cpp458-530

Platform-Specific Handling

Desktop GL:

• Full feature support including polygon mode, primitive restart, clip origin
• Extension-based feature detection via GL_NUM_EXTENSIONS
• Base vertex support for large meshes (3.2+)

OpenGL ES 2.0 / WebGL 1.0:

• No VAO support (except on Emscripten via OES_vertex_array_object)
• Limited to 16-bit indices without base vertex
• Requires precision qualifiers in shaders (lowp, mediump)
• No GL_UNPACK_ROW_LENGTH (except with pixel unpack buffer)

OpenGL ES 3.0 / WebGL 2.0:

• VAO support
• highp precision available
• glBindSampler() support
• GL_UNPACK_ROW_LENGTH available

Sources: backends/imgui_impl_opengl3.cpp152-220 backends/imgui_impl_opengl3.cpp408-424

OpenGL 2 Backend (Legacy)

The OpenGL 2 backend (imgui_impl_opengl2.cpp/h) uses the fixed-function pipeline and is provided primarily for reference and very old systems.

When to Use OpenGL 2 Backend

Use Cases:

• Systems that cannot support shaders at all
• Learning/reference implementation (simpler code)
• Integration into legacy codebases using fixed-function pipeline

Limitations:

• No ImGuiBackendFlags_RendererHasVtxOffset (cannot handle 64k+ vertex meshes efficiently)
• Cannot reset shader state (no glUseProgram(0))
• Requires application to be in "compatible" GL state
• More invasive state management (cannot fully isolate from app)

Implementation Differences

Key Differences:

Aspect	OpenGL 3	OpenGL 2
Pipeline	Programmable (shaders)	Fixed-function
Vertex Data	VBO/VAO	Client-side arrays
Projection	Uniform matrix	Matrix stack (glOrtho)
Drawing	glDrawElements[BaseVertex]	glDrawElements
Texture	Shader sampling	Fixed-function units
State Isolation	Full backup/restore	Limited (no shader reset)

OpenGL 2 Rendering Setup:

• Uses glMatrixMode(GL_PROJECTION) and glOrtho() for orthographic projection
• Uses glEnableClientState() and glVertexPointer/glTexCoordPointer/glColorPointer
• Relies on GL_TEXTURE_ENV and fixed-function texture units
• Cannot call glUseProgram(0) or reset shader state

Sources: backends/imgui_impl_opengl2.cpp91-272

API Reference

OpenGL 3 Backend Functions

OpenGL 2 Backend Functions

Sources: backends/imgui_impl_opengl3.h34-48 backends/imgui_impl_opengl2.h31-43

Configuration and Customization

Compile-Time Configuration

Define these in your imconfig.h or before including the backend:

Runtime Configuration

Backend Flags (set automatically):

• ImGuiBackendFlags_RendererHasVtxOffset: Set on Desktop GL 3.2+ for large mesh support
• ImGuiBackendFlags_RendererHasTextures: Always set, enables dynamic font atlas

Texture IDs: User textures should be passed as (ImTextureID)(intptr_t)texture_id where texture_id is a GLuint OpenGL texture name.

Sources: backends/imgui_impl_opengl3.cpp375-379 backends/imgui_impl_opengl3.h46-58

Embedded GL Loader

The OpenGL 3 backend includes a minimal GL function loader to eliminate external dependencies:

Features:

• Based on stripped-down gl3w
• Only loads functions used by the backend
• Automatically initializes on first use
• Can be disabled with IMGUI_IMPL_OPENGL_LOADER_CUSTOM

Supported Loaders: If you prefer external loaders, the backend is compatible with:

• GLEW
• glad / glad2
• glbinding 2.x / 3.x
• gl3w
• Custom loaders via IMGUI_IMPL_OPENGL_LOADER_CUSTOM

Regeneration: The loader can be regenerated using the gl3w_stripped project if new GL functions are needed.

Sources: backends/imgui_impl_opengl3_loader.h1-26 backends/imgui_impl_opengl3.cpp291-311