# Hello ImGui: one Dear ImGui codebase for desktop, mobile and web

> Hello ImGui is a C++ library on top of Dear ImGui that turns a GUI application into a cross platform one, covering Linux, Windows, macOS, iOS, Android and Emscripten through a single CMake call and an asset embedding step that needs no code. It also adds the parts Dear ImGui leaves out, such as power saving, high DPI handling, saved user settings and dockable layouts.

**pthom/hello_imgui** — Dear ImGui apps made simple: desktop, mobile, and web from one codebase. Minimal code. Maximally readable.

- Repository: https://github.com/pthom/hello_imgui
- Website: https://pthom.github.io/hello_imgui
- Stars: 917 · Forks: 117
- Language: C++
- License: MIT
- Published: 2026-10-20 · Updated: 2026-10-20 · Language: en
- Canonical page: https://hysenlabs.com/projects/pthom-hello-imgui

## Seven lines of C++ and one line of CMake

The pitch of the project is that the minimum code to start developing a GUI app should itself be minimal, and the example is a multiplatform hello world in seven lines.

```cpp
#include "hello_imgui/hello_imgui.h"
int main(int , char *[]) {
    HelloImGui::Run(
        []{ ImGui::Text("Hello, world!"); }, // Gui code
        "Hello!", true);                     // Window title + Window size auto
}
```

Six of those lines are C++ and the seventh is the build declaration.

```cmake
hello_imgui_add_app(hello_world hello_world.cpp)
```

Read what the arguments do. The first argument to Run is a lambda holding your GUI code, called every frame. The second is the window title. The third is a boolean that switches on automatic window sizing, so the application window resizes to fit the content rather than needing you to pick a pixel size.

There is no window creation, no render loop, no platform initialisation and no main loop to write. That is the entire value proposition, and it is a real one: the platform code is exactly the code that differs between a desktop build, an iOS build and an Emscripten build, and it is the code you would otherwise be rewriting three times.

The library is built on Dear ImGui itself, so what you write inside the lambda is Dear ImGui code with all the widgets you already know, and it stays that way as you grow the application.

## One codebase across six platform families

The platform support is listed as Linux, Windows, macOS, iOS, Android and Emscripten, with minimal setup described as one line of CMake code. Emscripten is the interesting entry because it means the same source can compile to WebAssembly and run in a browser.

The platform backends available are SDL2 and Glfw3. The rendering backends are OpenGL3, Metal, Vulkan and DirectX. That combination covers the modern graphics APIs across the platforms, and the CI configuration in the repository tracks them separately: there are workflows for Windows, macOS and Linux, for MinGW, for iOS, for Android, for Emscripten, and one each for Metal, Vulkan and DirectX, plus workflows for the test engine, the automation tooling and the starter template.

That list of workflows is a good proxy for how much surface the project actually covers. Continuous integration for Metal, Vulkan, DirectX and Emscripten separately means each of those combinations is compiled and tested rather than merely claimed.

The description says the library is designed to make multiplatform app development as simple as writing a hello world program, and that its flexibility suits both complex applications and simple prototypes. The flexibility claim is the one to check against your own project, since a framework that hides the platform layer can also hide it in the places where you need it.

## Assets and app identity without writing code

The multiplatform utilities section lists four capabilities, three of which are explicitly code free.

Asset embedding across all platforms needs no code, which means your images, fonts and other resources travel with the application binary rather than being looked up at runtime. That matters on mobile, where a file system path is not a reliable way to find a resource, and it means your application is one file to distribute rather than a directory plus a binary.

App customisation, including icons and names for the mobile platforms, also needs no code. The universal application icon customisation extends that to mobile and macOS, so one icon file produces the right icon everywhere the platform expects one, including the sizes and formats each system asks for.

This is unglamorous work that every desktop-to-mobile port otherwise eats weeks on, and it is the part of the library most likely to save you time rather than merely reduce typing.

The deployment side is handled by vcpkg.json and vcpkg-configuration.json in the repository root, plus a CMakePresets.json, so the dependency acquisition is declarative rather than a script you maintain.

## What Hello ImGui adds on top of Dear ImGui

The Dear ImGui tweaks section is the reason to use this rather than Dear ImGui directly, and several entries address things Dear ImGui intentionally leaves to the application.

Power Save mode optimises performance by reducing the frame rate when the application is idle. That is a battery and CPU feature that matters on laptops and phones, and it is also what makes an idle application feel cheap rather than hot.

High DPI support automatically scales the interface to match the screen DPI on any platform, which is the single most common complaint about immediate mode GUIs on modern displays.

Enhanced layout handling gives you dockable windows and multiple layouts for complex interfaces, and the docking demo is described as showing how to handle complex layouts, use themes, store user settings, reduce frame rate and CPU usage when idling, and load fonts and icons.

Window geometry utilities handle autosizing the application window and restoring its position, and there is support for movable and resizable borderless windows. Save user settings covers window position, layout, opened windows, theme and user defined custom settings, which is the persistence layer most immediate mode applications end up writing badly.

The rest are narrower: theme tweaking with an extensive list of additional themes, advanced font support for icons, emojis and coloured fonts, and a custom 3D background option.

## Testing and automating an immediate mode interface

Integration with the ImGui Test Engine is listed among the features, with the point of automating and testing your apps. That is a capability Dear ImGui itself provides but that many application teams never adopt, and for an immediate mode interface it is unusually practical, because the test engine works from the same declarative widget calls your rendering loop already makes.

The repository backs this with two dedicated CI workflows, one for the TestEngine and one for Automate, so the automation tooling is exercised on every push rather than being a script nobody runs.

A related artefact is the ImGui Manual, an interactive manual for Dear ImGui that was itself built with Hello ImGui. The project describes it as an interactive manual, and it is a useful reference implementation because it is a real application doing real layout work, with its own source repository.

The RPN Calculator is a second example, described as built to demonstrate how easy a multiplatform app can be built with Hello ImGui, again with an online demo and a source repository.

Together these three, the docking demo, the interactive manual and the calculator, show the library being used for real applications rather than only for the hello world case, and each of them runs as an online demo compiled with Emscripten.

## Documentation as a book you can feed to a model

The full manual is published as a PDF, and the project suggests you can feed it into an LLM such as ChatGPT so it can help you while using the library. That is an unusual instruction to find in a README, and it says something about how the documentation is written.

The documentation website is the primary reference for API, usage and build instructions, and the README explicitly defers to it rather than duplicating it.

The repository shows how the docs are produced. The doc_build recipe runs a Python script over the Markdown sources and then builds the book twice with jupyter book, once for html and once for pdf.

```bash
    python docs_src/process_md_docs.py
    cd docs_src && jupyter book build --html && jupyter book build --pdf
```

The serve recipe runs the same processing script and then jupyter book start, which gives you a live preview while editing. The docs_src/ directory holds the sources, and the top level also has a README.src.md, which indicates the README itself is generated or maintained alongside the documentation sources.

A starter template repository is offered as a separate project, described as getting you started in five minutes and showing how to embed assets and customise the app icon on all platforms. It has its own CI workflow, so it is tested rather than merely published.

## Versions, licence and the trade-off you are accepting

The release history shows regular work. The listed versions are v1.92.901 from 2026-10-02, v1.92.900 from 2026-08-13 and v1.92.700 from 2026-04-24, and the repository is not archived with the last push on 2026-10-19. The version numbers track the Dear ImGui release they are built against, which tells you the library is pinned to a specific upstream version rather than floating.

The licence is MIT, recorded in the LICENSE file at the repository root, and the Dear ImGui Bundle project built on top of it is also offered as a separate library with additional widgets.

The trade-off is straightforward and worth stating plainly. Dear ImGui is an immediate mode interface library, and it draws its own widgets rather than using the platform controls, so your application looks the same everywhere it runs. If you are shipping to end users who expect their platform's look and feel, this is the wrong family of tool, and no amount of platform coverage in the build configuration changes that.

Within that family, the trade is that you write a small amount of plumbing once and then write Dear ImGui code forever, with no layout system, no widget library and no styling system beyond what you build or import. Hello ImGui removes the plumbing. It does not change the nature of the interface, and it does not add a layout or styling system.

The repository layout reflects a real project rather than a demo. There are src/, cmake/, docs_src/, external/, tools/ and hello_imgui_cmake/ directories, an _example_integration directory, a .clang-format and a .clang-tidy configuration, a justfile for task running, a CMakePresets.json, a hello_imgui_example.ini and a vcpkg configuration, plus a Changelog.md.

## Conclusion

Adopt Hello ImGui if you want to ship the same Dear ImGui application on desktop, mobile and the web and you would rather not maintain three platform projects, since the platform abstraction, asset embedding and window setup live in the library rather than in your code. Do not adopt it if you need a native look and feel on each platform, because an immediate mode GUI is its own visual language everywhere it runs, and do not expect it to remove the need for Dear ImGui knowledge, since your application code is Dear ImGui code. Verify first that your target platform is covered by the platform backends you intend to use, that the rendering backend combination you want is supported, and that you read the documentation site, since the README defers the API, usage and build instructions to it.

## FAQ

### How do I build a multiplatform Hello ImGui application?

Include hello_imgui/hello_imgui.h, call HelloImGui::Run with a lambda holding your GUI code, a window title and a boolean for automatic window sizing, then declare the app in CMake with hello_imgui_add_app(hello_world hello_world.cpp). The platform backends are SDL2 and Glfw3 and the rendering backends are OpenGL3, Metal, Vulkan and DirectX.

### Which platforms does Hello ImGui support?

Linux, Windows, macOS, iOS, Android and Emscripten, which is the WebAssembly path that lets the same source run in a browser. The repository runs separate CI workflows for each of those platform families and for the Metal, Vulkan and DirectX rendering backends.

### Does Hello ImGui embed assets and app icons automatically?

Yes, asset embedding across all platforms is listed as requiring no code, and app customisation including icons and names for the mobile platforms also requires no code, with universal application icon customisation extending to mobile and macOS.

### What does Hello ImGui add to plain Dear ImGui?

Power Save mode that reduces frame rate when idle, automatic high DPI scaling, dockable windows and multiple layouts, window geometry utilities, theme tweaking, advanced font support for icons and emojis, saving of user settings such as window position and layout, custom 3D backgrounds, and integration with the ImGui Test Engine for automating and testing your apps.

## Sources

- [License: MIT](https://github.com/pthom/hello_imgui/blob/master/LICENSE)
- [Project website](https://pthom.github.io/hello_imgui)
- [pthom/hello_imgui on GitHub](https://github.com/pthom/hello_imgui)
- [README](https://github.com/pthom/hello_imgui/blob/master/README.md)
- [Releases](https://github.com/pthom/hello_imgui/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/pthom-hello-imgui