Dear ImGui: A C++ GUI Library for Developers

What is Dear ImGui?

Dear ImGui is a bloat-free C++ library that generates a graphical interface as a stream of optimized vertex buffers your own renderer draws, instead of managing native OS windows or widgets. It has no required build step: you drop the core .cpp/.h files into an existing C++ project and pair them with one of the maintained backends for DirectX, OpenGL, Vulkan, Metal, or WebGPU.

The Immediate Mode GUI Approach

Traditional retained-mode GUI toolkits ask you to keep two copies of state in sync: the widget tree's internal state and your own application data, bridged by change events and callbacks. Two copies of state means two places to get it wrong. Dear ImGui's own opening quote, credited to someone using the handle ryg, jokes that this exact synchronization problem is what causes bugs that last a lifetime. The immediate-mode approach it uses instead redraws the whole interface from your live data every frame, so there is one source of truth and less code keeping two things in sync. That is specifically why it fits content-creation tools, visualization panels, and debug interfaces, where the underlying data changes constantly and a widget tree that lags behind becomes a liability.

Key Features and Benefits

• ✓Core is self-contained in a handful of platform-agnostic files (imgui*.cpp, imgui*.h) that you compile straight into your project — no build system or package manager required.
• ✓Officially maintained renderer backends ship in the backends/ folder for DirectX9/10/11/12, Metal 3/4, OpenGL/ES/ES2, SDL_GPU, SDL_Renderer2/3, Vulkan, and WebGPU.
• ✓Platform backends cover GLFW, SDL2/SDL3, Win32, Glut, OSX, and Android, plus framework backends for Allegro5 and Emscripten.
• ✓Renderer-agnostic output: Dear ImGui produces vertex buffers and draw-call batches rather than touching your GPU directly, so anywhere you can render textured triangles, you can render its UI.
• ✓Built-in demo window (ImGui::ShowDemoWindow()), with source in imgui_demo.cpp, shows off widgets and patterns you can copy into your own code.
• ✓Hot-reload friendly: because state lives in your own variables rather than a retained widget tree, you can add or remove widgets while the app keeps running under compiler Edit-and-Continue.
• ✓Extension ecosystem includes ImPlot and ImPlot3d for plotting and Dear ImGui Test Engine for automation and regression testing, called out by the README as notable and well supported.

Ideal Use Cases

• •Debug overlays and live tuning panels inside a game or real-time 3D application, added and removed without restarting.
• •In-house content-creation tools and level or asset editors for a game engine, where the UI needs to track a constantly changing dataset.
• •Profilers, loggers, and inspection tools — the README points to Tracy (profiler), ImHex (hex editor/data analysis), and RemedyBG (debugger) as examples built on Dear ImGui.
• •Tooling for embedded or console targets, where Dear ImGui's minimal dependencies and portability matter more than native OS widget styling.

Getting Started with Dear ImGui

Dear ImGui has no required build step: the core lives in a few platform-agnostic files (imgui*.cpp, imgui*.h) at the repository root, which you compile straight into an existing C++ project. You then pick a backend from the backends/ folder matching your rendering API and platform — for example imgui_impl_win32.cpp paired with imgui_impl_dx11.cpp — and wire up three things yourself: input (mouse/keyboard/gamepad), a GPU texture upload, and a render function that draws textured triangles. The README says this typically takes under an hour if you're linking against a standard backend, and points to a dedicated Getting Started wiki guide plus the Backends guide in docs/BACKENDS.md for the details. C++20 users who want a module can reach for the third-party stripe2933/imgui-module extension instead of the plain files.

Building User Interfaces

Once a backend is wired up, you call the same handful of functions from anywhere in your program loop — there's no separate widget-tree setup step. A minimal frame looks like: ```cpp ImGui::Begin("My Tool"); ImGui::Text("FPS: %.1f", fps); if (ImGui::Button("Reload")) ReloadAssets(); ImGui::SliderFloat("Gravity", &gravity, 0.0f, 20.0f); ImGui::End(); ``` Because the UI just reflects whatever your own variables hold at the moment `ImGui::Begin`/`ImGui::End` runs, you can drive a window straight from live data: plot values with `ImGui::PlotLines`, expose an internal struct field, or trace a running algorithm by emitting text each frame. Docking, menus, and child regions compose the same way — nest the calls inside `Begin`/`End` and the layout follows the call order.

Other C++ GUI Options

Frequently Asked Questions

Who should try it — and who should skip

Try Dear ImGui if you're a C++ developer building tooling inside a game engine, a real-time renderer, or an embedded app — debug panels, editors, profilers, and similar internal tools are exactly what the README says it's designed for. Skip it if you're building the primary UI for an end-user product: there's no internationalization, no accessibility support, and no native widget styling, so a retained-mode toolkit like Qt or wxWidgets will save you more trouble there.

Related repositories