Support for building Vulkan backend Python pyd module

[feifeid47]

Hi there! 👋

First of all, thanks a lot for maintaining such an amazing and user-friendly Dear ImGui Bundle project! I've been using ImGui Bundle for about 3 months to develop real-time Python GUI tools for 3D rendering and interactive visualization. So far the experience with the OpenGL backend has been smooth and awesome.

Currently, I am trying to upgrade my project to use the Vulkan rendering backend for better rendering performance and lower CPU overhead, and I would like to ask for official support for building Vulkan backend-based Python .pyd modules in ImGui Bundle.

Issue Description

I notice that ImGui Bundle supports Vulkan backend for C++ development, but I cannot find official support or build options to compile Python .pyd binaries with the Vulkan rendering backend enabled.

My current project requires Vulkan's better graphics performance and multi-threaded rendering capabilities compared to OpenGL. I want to confirm:

1. Does ImGui Bundle officially support building Python bindings (.pyd) with the Vulkan backend?

2. If supported, are there any specific build commands, CMake flags or configuration steps I need to follow to compile the Vulkan-version pyd module?

3. If not supported yet, is there any plan to add Vulkan backend support for Python builds in the future?

[pthom]

Hi, and thanks for the kind words. I'm glad ImGui Bundle has been useful for your work!

Short answers to your three questions, then a suggestion that I think gets you what you actually want.

1. Is there official Vulkan support for the Python bindings?

No. The Python bindings force GLFW3 + OpenGL3 at configure time (see CMakeLists.txt, in the IMGUI_BUNDLE_BUILD_PYTHON block). Vulkan is supported for C++ builds only.

2. Build flags for a Vulkan .pyd?

There are none, and I don't recommend trying to force it. Beyond HelloImGui itself, several bundled libraries talk to OpenGL directly — ImmVision, NanoVG, the imgui_md image loader, ImFileDialog's texture helper, imgui_tex_inspect. ImGui 1.92's backend-owned texture API covers ImGui's own textures, but those libraries expose GL handles to user code. A Vulkan build wouldn't just be a flag flip; those features would break.

3. Any plans to add it?

No plans, for distribution reasons rather than technical ones. Vulkan needs a loader present at runtime, so there is no single wheel that works everywhere — it would mean a separate wheel variant and Vulkan SDK provisioning across the whole (3 OS × N Python versions) release matrix. That is a permanent maintenance cost on the release path, for something very few users need.

What I'd suggest instead: wgpu (WebGPU for Python)

Before going further, one thing worth checking: the performance argument may not hold for a Python app. Per-frame cost in an ImGui UI driven from Python is dominated by the interpreter walking your widget tree, not by draw submission — ImGui emits a handful of draw calls over one vertex buffer, so OpenGL vs Vulkan is usually noise at that scale. And multi-threaded rendering isn't reachable from Python anyway (GIL, and the ImGui context is single-threaded by design). If you haven't already, profile the Python side first — you may find the bottleneck is somewhere else entirely.

That said, if you want a modern explicit GPU API from Python, there is already a supported path — and it runs on Vulkan under the hood (wgpu-native uses Vulkan on Linux, D3D12 on Windows, Metal on macOS):

pip install "imgui-bundle[wgpu]"     # or: pip install wgpu rendercanvas
pip install glfw

import wgpu
from imgui_bundle import imgui
from rendercanvas.auto import RenderCanvas, loop
from wgpu.utils.imgui import ImguiRenderer

canvas = RenderCanvas(title="imgui", size=(640, 480), max_fps=60, update_mode="continuous")
adapter = wgpu.gpu.request_adapter_sync(power_preference="high-performance")
device = adapter.request_device_sync()
print(adapter.info)          # shows which native backend was selected

imgui_renderer = ImguiRenderer(device, canvas)

def update_gui():
    imgui.show_demo_window()

imgui_renderer.set_gui(update_gui)

if __name__ == "__main__":
    canvas.request_draw(imgui_renderer.render)
    loop.run()

A complete runnable example ships with the bundle:
[bindings/imgui_bundle/python_backends/examples/example_python_backend_wgpu.py](https://github.com/pthom/imgui_bundle/blob/main/bindings/imgui_bundle/python_backends/examples/example_python_backend_wgpu.py)

More examples (the ones named imgui_*) are in the wgpu-py repo:
https://github.com/pygfx/wgpu-py/tree/main/examples

This gives you what I think you're really after: an explicit, modern GPU API for your own 3D rendering, with ImGui composited on top. This way, you avoid the SDK/wheel problems, since wgpu ships its own native library as a normal pip wheel. It's also a good fit for 3D visualization work generally: [pygfx](https://github.com/pygfx/pygfx) is a full render engine built on the same stack.

Note that you lose the HelloImGui conveniences this way (DPI handling, themes, docking setup, asset management): you drive the window and the frame loop yourself. See the [Pure Python Backends](https://github.com/pthom/imgui_bundle/blob/main/docs/book/python/pure_python_backend.md) docs.

If you'd rather stay on OpenGL but keep control of the loop, [moderngl-window](https://github.com/moderngl/moderngl-window/blob/master/examples/integration_imgui.py) also has an ImGui Bundle integration.

Hope this helps.