# Dear ImGui Backends: Every Official Platform and Renderer Option Explained

> Explore all 20 official Dear ImGui backends for windowing and GPU rendering. Discover platform and renderer options to integrate ImGui into any application seamlessly.

- Repository: [omar/imgui](https://github.com/ocornut/imgui)
- Tags: deep-dive
- Published: 2026-07-21

---

**Dear ImGui ships with 20 official backends inside the `backends/` folder—11 platform backends for windowing and input, and 9 renderer backends for GPU draw-list execution—that you pair together to integrate the library into any application.**

Dear ImGui (ocornut/imgui) is designed as a self-contained UI library that relies on external backends to connect to the operating system and graphics hardware. The repository's `backends/` directory contains the complete set of officially maintained reference implementations, each following the `imgui_impl_*.cpp/.h` naming convention. Understanding which **ImGui backends** exist and how they interact is essential for choosing the right integration strategy for your project.

## Architecture of Dear ImGui Backends

Each backend bridges a specific gap between the core Dear ImGui library and the host application. **Platform backends** handle windowing, input devices, clipboard access, and IME composition by populating fields in `ImGuiIO`. **Renderer backends** consume ImGui's draw-list data and transform it into GPU commands, managing vertex buffers, textures, and render state. A typical integration uses exactly one platform backend and one renderer backend simultaneously, although the **Null** platform backend can be paired with any renderer for headless testing.

## Official Platform Backends

The platform backends reside in `backends/imgui_impl_*.cpp/.h` files and wrap the native windowing and event loop of the target OS or library.

- **Win32** — `backends/imgui_impl_win32.cpp/h` handles the Windows window procedure, mouse and keyboard input, clipboard, and IME.
- **GLFW** — `backends/imgui_impl_glfw.cpp/h` provides cross-platform windowing and input for GLFW 2 and GLFW 3.
- **SDL2** — `backends/imgui_impl_sdl2.cpp/h` integrates SDL 2 windows, events, clipboard, and game-controller input.
- **SDL3** — `backends/imgui_impl_sdl3.cpp/h` is the updated platform layer for SDL 3.
- **SDL_Renderer 2** — `backends/imgui_impl_sdlrenderer2.cpp/h` targets SDL 2's built-in 2D renderer API.
- **SDL_Renderer 3** — `backends/imgui_impl_sdlrenderer3.cpp/h` targets SDL 3's built-in 2D renderer API.
- **SDL_GPU 3** — `backends/imgui_impl_sdlgpu3.cpp/h` connects directly to SDL 3's low-level GPU API.
- **GLUT / FreeGLUT** — `backends/imgui_impl_glut.cpp/h` offers legacy GLUT windowing, primarily for quick demos.
- **Allegro 5** — `backends/imgui_impl_allegro5.cpp/h` wraps Allegro 5 window and input facilities.
- **Android** — `backends/imgui_impl_android.cpp/h` manages native Android windows and touch input.
- **Null** — `backends/imgui_impl_null.cpp/h` is a no-op platform backend useful for automated unit tests.

## Official Renderer Backends

Renderer backends implement the `RenderDrawData` phase and are responsible for turning ImGui's geometry into visible pixels.

- **OpenGL 2** — `backends/imgui_impl_opengl2.cpp/h` uses the legacy OpenGL 2.x fixed-function pipeline.
- **OpenGL 3** — `backends/imgui_impl_opengl3.cpp/h` uses a modern OpenGL 3+ core-profile shader pipeline.
- **Vulkan** — `backends/imgui_impl_vulkan.cpp/h` implements a full Vulkan rendering path.
- **DirectX 9** — `backends/imgui_impl_dx9.cpp/h` targets DirectX 9.
- **DirectX 10** — `backends/imgui_impl_dx10.cpp/h` targets DirectX 10.
- **DirectX 11** — `backends/imgui_impl_dx11.cpp/h` targets DirectX 11.
- **DirectX 12** — `backends/imgui_impl_dx12.cpp/h` targets DirectX 12.
- **WebGPU** — `backends/imgui_impl_wgpu.cpp/h` provides an experimental renderer via the wgpu implementation of WebGPU.

## Common Backend Pairings and Code Examples

The following snippets demonstrate how to initialize typical platform-plus-renderer combinations. All examples assume the corresponding `imgui_impl_*.cpp` sources are compiled into the project.

### GLFW and OpenGL 3

A widely used cross-desktop pairing. The GLFW backend creates the window surface and captures input, while the OpenGL 3 backend compiles shaders and draws geometry.

```cpp
// Main.cpp (excerpt)
ImGui::CreateContext();
ImGuiIO& io = ImGui::GetIO();
io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard; // optional

// Initialise platform back-end
ImGui_ImplGlfw_InitForOpenGL(window, true);
// Initialise renderer back-end
ImGui_ImplOpenGL3_Init("#version 130");

// Main loop
while (!glfwWindowShouldClose(window))
{
    glfwPollEvents();
    ImGui_ImplOpenGL3_NewFrame();
    ImGui_ImplGlfw_NewFrame();
    ImGui::NewFrame();

    // …your UI code…

    ImGui::Render();
    ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());
    glfwSwapBuffers(window);
}

```

### Win32 and DirectX 11

For native Windows applications, the Win32 platform backend manages the `HWND` message loop and raw input events. The DirectX 11 renderer backend accepts the `ID3D11Device` context and submits indexed draw calls for ImGui's vertex buffers.

```cpp
// Win32 DirectX11 initialisation (excerpt)
ImGui::CreateContext();
ImGuiIO& io = ImGui::GetIO();

ImGui_ImplWin32_Init(hwnd);                     // Platform
ImGui_ImplDX11_Init(device, device_context);    // Renderer

// In the render loop
ImGui_ImplDX11_NewFrame();
ImGui_ImplWin32_NewFrame();
ImGui::NewFrame();

/* UI code */

ImGui::Render();
ImGui_ImplDX11_RenderDrawData(ImGui::GetDrawData());

```

### SDL2 and Vulkan

This pairing uses SDL2 for portable window and event management and Vulkan for explicit, low-level GPU control. The platform setup uses `ImGui_ImplSDL2_InitForVulkan`, while the renderer requires an `ImGui_ImplVulkan_InitInfo` structure and a valid Vulkan render pass.

```cpp
ImGui::CreateContext();
ImGuiIO& io = ImGui::GetIO();

ImGui_ImplSDL2_InitForVulkan(window);   // Platform
ImGui_ImplVulkan_Init(&init_info, render_pass); // Renderer

// Each frame
ImGui_ImplVulkan_NewFrame();
ImGui_ImplSDL2_NewFrame(window);
ImGui::NewFrame();

/* UI code */

ImGui::Render();
ImGui_ImplVulkan_RenderDrawData(ImGui::GetDrawData(), command_buffer);

```

### Null and OpenGL 2 for Headless Testing

When running automated tests or logic-only validation, the **Null** platform backend satisfies ImGui's input requirements without creating a real window. The OpenGL 2 renderer still processes draw data, allowing `ImGui::Render()` to execute in headless environments.

```cpp
ImGui::CreateContext();
ImGui_ImplNull_Init();                // No platform input
ImGui_ImplOpenGL2_Init();             // Renderer (still required for drawing)

// Render loop omitted – useful for unit-test scenarios where you only call ImGui::Render()

```

## Summary

- Dear ImGui's official **ImGui backends** live in the `backends/` folder and follow the `imgui_impl_*.cpp/.h` naming convention.
- **Platform backends** feed OS events, mouse state, keyboard input, clipboard, and IME data into `ImGuiIO`.
- **Renderer backends** consume ImGui draw lists and emit GPU commands through vertex buffers and texture bindings.
- A standard application combines **one** platform backend with **one** renderer backend, such as `GLFW + OpenGL3` or `Win32 + DirectX11`.
- The **Null** platform backend enables headless, UI-only testing when paired with any renderer backend.
- Every backend exposes the same lifecycle hooks—`Init`, `NewFrame`, `RenderDrawData`, and `Shutdown`—making custom implementations straightforward.

## Frequently Asked Questions

### What is the difference between a platform backend and a renderer backend?

Platform backends, such as [`imgui_impl_glfw.cpp`](https://github.com/ocornut/imgui/blob/main/imgui_impl_glfw.cpp) or [`imgui_impl_win32.cpp`](https://github.com/ocornut/imgui/blob/main/imgui_impl_win32.cpp), connect the host windowing system to Dear ImGui by filling `ImGuiIO` fields with mouse, keyboard, and clipboard state. Renderer backends, such as [`imgui_impl_opengl3.cpp`](https://github.com/ocornut/imgui/blob/main/imgui_impl_opengl3.cpp) or [`imgui_impl_vulkan.cpp`](https://github.com/ocornut/imgui/blob/main/imgui_impl_vulkan.cpp), interpret ImGui's output draw lists and translate them into the shading, buffer, and draw commands required by the target graphics API.

### Can I mix any platform backend with any renderer backend?

Yes. Dear ImGui's architecture deliberately separates windowing from rendering, so you can combine almost any platform backend with any renderer backend. Popular combinations include `GLFW + OpenGL3` for cross-platform desktops, `SDL2 + Vulkan` for explicit GPU control, and `Win32 + DirectX12` for native Windows performance.

### Which ImGui backend should I choose for a new cross-platform project?

For new desktop projects, the **GLFW** platform backend paired with the **OpenGL 3** renderer is the most common and well-documented starting point. GLFW abstracts Windows, macOS, and Linux windowing, while the OpenGL 3 backend provides a modern, shader-based pipeline that is easy to integrate with existing OpenGL code.

### How do I implement a custom backend for an unsupported platform?

Study [`backends/imgui_impl_null.cpp`](https://github.com/ocornut/imgui/blob/main/backends/imgui_impl_null.cpp) for the minimal required surface area, then implement the four core functions—`ImGui_ImplXXXX_Init`, `ImGui_ImplXXXX_NewFrame`, `ImGui_ImplXXXX_RenderDrawData`, and `ImGui_ImplXXXX_Shutdown`—and set the relevant flags in `ImGuiIO::BackendFlags`. Reference [`backends/imgui_impl_win32.cpp`](https://github.com/ocornut/imgui/blob/main/backends/imgui_impl_win32.cpp) and [`backends/imgui_impl_opengl3.cpp`](https://github.com/ocornut/imgui/blob/main/backends/imgui_impl_opengl3.cpp) for complete platform and renderer implementations.