Talk:Immediate mode GUI

The idea of immediate mode GUI is similar to that used by React.js.

Comment from ocornut, author of dear imgui:


 * The page is misleading e.g. "The original Immediate Mode GUI toolkit was imgui[1] which is based on OpenGL" and rather poorly describe the nature of the IMGUI paradigm and its origin. The idea was popularized by Casey Muratori but others were threading on the same concept e.g. ZMW.


 * The readme of Dear ImGui has a section called "References" linking to various pages I would suggest reading if you are interested in contributing to this Wikipedia page. Most would be worth linking from the Wikipedia page, and they would be a good read to create a better explanation of the IMGUI paradigm. I think "where the event processing is directly controlled by the user." is an interesting formulation but the key element as defined by Muratori is the aspect of retained (RMGUI) vs non-retained ui (IMGUI). In the later, the user code is holding on its own natural data. The articles mentioned before will paint a clearer picture.


 * kiss_sdl is not an IMGUI, quite the contrary since both the user and the UI are retaining widgets.

— Preceding unsigned comment added by OmarCornut (talk • contribs) 10:31, 4 October 2018 (UTC)

I would not say contrary, i don't think that's the right word. The UI retains the widget data, but it is not hidden from the user, and the user controls the event processing. What is completely contrary is a GUI where all GUI processing is hidden from the user, and there are a number of such. It should be distinguished whether the intent is to hide the GUI processing from the user or make it more immediate. Eiusmod (talk) 00:49, 30 November 2018 (UTC)

This page is very poorly written, and poorly describes what a IMGUI is. Most of the 'disadvantages' are misguided or outright wrong, and depend far more on implementation details, than the nature of the concept.

In essence a imgui is a gui system where the programmer is in control of the rendering loop, and the entire UI is redrawn every render cycle. This can be achieved either by calling functions which render UI elements to the frame-buffer, or by building a data structure which describe the UI, which is passed to a function that renders the elements. The difference in the latter case that differentiates it from a retained mode gui, is that the data structure is thrown away every frame, never updated, and thus ui controls do not hold state.

The latter point is another differentiator, as the state of UI controls is not 'encapsulated' within the controls themselves, but rather stored by the application code and fed into the UI every frame, and events on the UI are passed back, and the application state is updated. Thus there is no duplication of state between the UI, and application code.

the following is a JavaScript example of a hypothetical IMGUI text input.

I'll go further than the above and suggest that this page as it is should be deleted. There are so many problems with it that it cannot be reasonably improved piecemeal. I propose that this page be deleted and that, if it's to survive, it should be from an entirely new page. SeanAhern (talk) 18:42, 22 October 2021 (UTC)


 * I unfortunately 100% agree with this statement. This page has so many problems I would also suggest to delete it, and wait for it to be recreated by people who are interested in the topic and its history (there are many references to read). OmarCornut (talk) 12:05, 9 November 2022 (UTC)