thedmd/imgui-node-editor: A Node Graph Layer for Dear ImGui

What imgui-node-editor actually takes off your plate

Dear ImGui gives you widgets, not a canvas. If you want a graph where users drag nodes around, zoom, rubber-band select, and connect pins with curved links, you write that interaction layer yourself: hit testing, panning, zoom transforms, selection state, and the bookkeeping that keeps node positions stable across frames. imgui-node-editor is that layer, packaged as source files you drop into an ImGui host. The README states the project's purpose is to serve as a basis for more complex solutions like blueprint editors, and that the editor was used to implement the blueprint editor in Spark CE engine.

The intended audience is C++ teams already committed to ImGui, typically in game development or tooling. The topics list on the repository includes blueprint, game-development and gamedev, which matches the README's framing. If your application has no ImGui context, this library has nothing to attach to. It is not a standalone application, not a web canvas, and not a retained-mode scene graph you can query after the fact.

The draw-your-content, we-do-the-rest contract

The design rule is stated plainly in the README: draw your content, we do the rest. Interactions are handled by the editor; content rendering is handled by the user. Concretely, you call ed::Begin and ed::End around a frame, and inside that you call ed::BeginNode with a unique integer id, draw whatever ImGui widgets you want, declare pins with ed::BeginPin and ed::EndPin, then call ed::EndNode. The editor owns placing nodes in the world, dragging, zoom and scrolling, selection, and the queries for creation, deletion and selection changes.

That split is why the API feels like ImGui: you are still in immediate mode, emitting draw calls every frame. Node and pin contents are fully customizable according to the README, and links are drawn as customizable Bézier curves. Styling is flexible enough that the README shows nodes modeled after UE4 blueprints. State that must persist across frames, such as layout, is kept in an editor context you create with ed::CreateEditor and point at a settings file. The README notes node state can be saved in user context so layout will not break. The repository layout backs this up: imgui_node_editor.cpp holds the implementation, imgui_node_editor_api.cpp the query surface, and imgui_canvas.cpp the pan, zoom and selection machinery, with imgui_bezier_math.h and imgui_extra_math.h supplying the geometry.

Installing imgui-node-editor by copying sources

There is no package manager step. The README states node editor sources are located in the root project directory and that to use it you simply copy and paste sources into your project, exactly like you can do with ImGui. The dependencies are vanilla ImGui 1.72 or newer and C++14. The main header is imgui_node_editor.h.

If you want to see the examples first, the README gives CMake commands. These build the sample applications into build/bin:

cmake -S examples -B build -G "Unix Makefiles"
cmake --build build --config Release

On Windows the README offers Visual Studio generators instead, for example cmake -S examples -B build -G "Visual Studio 16 2019" -A x64. On macOS it uses the Xcode generator.

The README's minimal example creates an editor context with a settings file and draws a single node with one input and one output pin. The essential calls look like this:

ed::Config config;
config.SettingsFile = "Simple.json";
m_Context = ed::CreateEditor(&config);

ed::SetCurrentEditor(m_Context);
ed::Begin("My Editor", ImVec2(0.0, 0.0f));
ed::BeginNode(uniqueId++);
    ImGui::Text("Node A");
    ed::BeginPin(uniqueId++, ed::PinKind::Input);
        ImGui::Text("-> In");
    ed::EndPin();
ed::EndNode();
ed::End();
ed::SetCurrentEditor(nullptr);

Each node and pin needs a unique id, which the README example produces with a running counter. If you see only a grid after starting, the README says to press F in the editor to focus on editor content. The settings file named in ed::Config is where layout persistence lands.

Where imgui-node-editor stops being the right tool

The library draws and manages a graph; it does not define one. There is no node type system, no evaluation order, no serialization format for the graph itself beyond the layout state the editor keeps. You write the model, the pin compatibility rules, and the execution semantics. A team expecting a ready-made dataflow runtime will find the repository layout tells the real story: the root is editor and canvas code plus a small JSON helper, crude_json.cpp, used by examples, not a graph engine.

The release cadence is the other constraint. v0.9.3 is a bugfix release dated 2023-10-14, v0.9.2 is described as a stable branch, and the initial v0.9 release dates from 2019-07-16. The README itself says the project is slowly moving into stable state from being a prototype and asks users to report issues or questions. Treat the master branch as a moving target if you vendor it. The README does not document a rollback procedure or a deprecation policy, so pinning to a specific commit is on you.

One more boundary: the blueprints sample depends on a separate ImGui fork, https://github.com/thedmd/imgui/tree/feature/layout, and the README lists optional ImGui extensions for extra shortcuts. If you need the blueprints example to build, you are pulling a non-upstream ImGui branch as well.

imgui-node-editor compared with imnodes

The search terms around this project frequently land on imnodes, and the difference is architectural rather than cosmetic. imnodes is a separate library with its own API surface for nodes and links. imgui-node-editor instead aims for an ImGui-style API, as the README puts it, which means the same immediate-mode pattern you already use for windows and widgets, with ed:: calls interleaved with ImGui:: calls inside the same frame.

That matters in two directions. If your UI is already ImGui-heavy, the ImGui-style API means less impedance mismatch and you can draw arbitrary widgets inside a node body. If you want a smaller, more self-contained node widget with fewer concepts, a dedicated library may be simpler to reason about. The other comparison the search data surfaces is Qt node editors, which sit in a retained-mode widget world; imgui-node-editor is immediate mode, so every node is redrawn each frame and there is no persistent widget tree to inspect. That is a deliberate trade: less state to synchronize, more drawing code to write.

Maintenance, upgrades and what the MIT licence lets you do

The repository is not archived. The last push was on 2026-03-29, so the code is being touched, but the tagged releases are far older: v0.9.3 on 2023-10-14, v0.9.2 on 2023-09-01, and v0.9 on 2019-07-16. Anyone tracking releases rather than commits should plan for the gap between the two.

Upgrade cost is mostly a vendoring problem. Because the README tells you to copy sources into your project, you own the diff. When you pull a newer copy, you reconcile it against your local edits by hand. There is no dependency resolver to do it. The README notes the project was recently restructured to mimic ImGui layout, which is exactly the kind of change that produces a large but mechanical diff in a vendored copy.

The licence is MIT, and the LICENSE file sits at the top level of the repository. That permits use in closed-source products, but the MIT text carries an attribution condition, so keep the copyright notice with the copied files. This is a description of the licence terms, not legal advice; if your product has unusual distribution requirements, have counsel read the LICENSE file.

Editorial conclusion

Adopt it if you already ship a Dear ImGui interface and want blueprint-style node editing without writing canvas interaction code; the README states the editor was used to implement the blueprint editor in Spark CE engine. Do not adopt it if you need a packaged dependency, a stable tagged API surface, or a retained-mode scene graph, because the README tells you to copy sources in and the latest release, v0.9.3, dates from 2023-10-14. Before committing, verify that your ImGui version is at least 1.72, check that imgui_node_editor.h compiles against your build, and confirm that the v0.9.2 stable branch, not master, is what you want to vendor.

Frequently asked questions

Official sources

1. Issues
2. License: MIT
3. README
4. Releases
5. thedmd/imgui-node-editor on GitHub