imgui

It's fun to see the evolution in e.g. these examples of image loading for Dear Imgui: https://github.com/ocornut/imgui/wiki/Image-Loading-and-Disp... DirectX9 will even load the image for you, DirectX11 okay we get a few more structures to fill out, DirectX12 is where it goes off the rails and we are filling out a bunch of UNKNOWN DONT_CARE JUST_DO_IT. Then of course Vulkan is the one that gets the big fat "this probably won't actually work for you" warning. I understand whats happening, but you know sometimes I just want to display a fucking image.

ImGui is engine/GPU agnostic Themeing isn't a just a retained mode thing, you can do wonders with immediate UIs, even though (dear)ImGui doesn't provide much, you can still do wonders: https://github.com/ocornut/imgui/issues/707#issuecomment-362... The gaming cheating community is quite creative as well: https://www.unknowncheats.me/forum/c-and-c-/505940-advanced-... More on that topic: https://www.youtube.com/watch?v=Z1qyvQsjK5Y

My first guess would be it is supposed to sound like "Dear Imogen". However, it wasn't initially conceived of as a reference to anything. The "Dear" was tacked on to qualify the name [1]. [1] https://github.com/ocornut/imgui/blob/master/docs/FAQ.md#q-w...

From the faq https://github.com/ocornut/imgui/blob/master/docs/FAQ.md#q-w... Q. What is this library called? This library is called Dear ImGui. Please refer to it as Dear ImGui (not ImGui, not IMGUI). (The library misleadingly started its life in 2014 as "ImGui" due to the fact that I didn't give it a proper name when I released 1.0, and had no particular expectation that it would take off. However, the term IMGUI (immediate-mode graphical user interface) was coined before and is being used in variety of other situations e.g. Unity uses it own implementation of the IMGUI paradigm. To reduce the ambiguity without affecting existing code bases, I have decided in December 2015 a fully qualified name "Dear ImGui" for this library.

Aside from bugs and driver issues, Wayland has some unfortunate design limitations. For example, Dear ImGui multi-viewports don't work because "Wayland doesn't let application read or write windows positions." https://github.com/ocornut/imgui/wiki/Multi-Viewports This is a feature available on Windows, macOS, and of course X11. Making choices like this means desktop Linux becomes even more of a weird island that nobody wants to support.

The STB headers are mostly built like that: https://github.com/nothings/stb Dear ImGui is a C++ example: https://github.com/ocornut/imgui You could also add an optional 'convenience layer' over the lower-level flexible-but-inconvenient core library, as long as the core library can be built and used without the convenience layer. In essence it's just a way to decouple the actually important library functionality from runtime environment details which might be better implemented outside the C and C++ stdlibs anyway. It's already as simple as the stdlib IO functions not being asynchrononous while many operating systems provide more modern and performant asynchronous IO APIs. For a specific type of library (such as an image decoder) it's often better to delegate such details to the library user instead of either using the stdlib or having the

> [...] you can build UIs that are snappy and keyboard driven. That's not an advantage that is exclusive to TUIs; after all, you're running your TUI inside a graphical application that emulates a terminal. (Unless you're rocking an actual VT102, in which case I bow down to you.) In fact there's an entire class of applications that are extremely snappy and keyboard driven, by their very nature: games. Some people have taken to writing GUI apps like you'd write a game, and the effects range from OK to fantastic. Check out Lagrange (https://gmi.skyjake.fi/lagrange/), AppManager (https://tildegit.org/solene/AppManager), Dear ImGUI (https://github.com/ocornut/imgui), egui (https://github.com/emilk/egui), and many others.

React is crazy high in abstraction from what's actually happening. Your data goes through many "translation" steps before actually being rendered to the screen. 1. You have your signals and stuff - the actual data you want rendered. 2. React creates a virtual DOM tree thing out of your markup. 3. That virtual DOM gets turned into real DOM. 4. React gives the real DOM to the browser, who probably has to shift a lot of internal data around to accommodate changes. 5. The browser loops through its DOM and draws it on the screen (somehow - another black box). This is a crazy amount of internal bookkeeping. Compare this with something like Dear ImGui (https://github.com/ocornut/imgui) where it's more like: 1. You have raw data in memory (just ints and char arrays). 2. You loop over your data, generating vertices for the GPU. 3. You give those v

ImGui spotted, someone should tell ocornut to add it to the list! https://github.com/ocornut/imgui/wiki/Software-using-dear-im...

Also here, what appeared to be a bug in ImGuis clipboard handling turned out to be a crypto stealer https://github.com/ocornut/imgui/issues/4029

> Take ImGui (https://github.com/ocornut/imgui, an immediate mode GUI library) for example - the examples are much closer to TUI interfaces than a Swift UI app - the only difference between that an a terminal UI would be that the lines are thinner and that text has non-uniform spacing. What I see there is a spatial interface with complex layout, z-axis and graphical elements. A bit hard to replicate on a normal terminal. > Does that make ImGui a TUI? TUI and GUI are not defined by the actual complexity of a real application, but the environment which gives them theoretical abilities. With a GUI, you can have pixel-perfect control over every element. With a TUI, you are normally limited to character-level of control. Of course can you also use pixels without a desktop, but you would still leave the terminal-environment and enter the frameb

I would say that the distinction between TUI and GUI - outside "how would I use this tool remotely" - is mainly one for the developer. Take ImGui (https://github.com/ocornut/imgui, an immediate mode GUI library) for example - the examples are much closer to TUI interfaces than a Swift UI app - the only difference between that an a terminal UI would be that the lines are thinner and that text has non-uniform spacing. Does that make ImGui a TUI? Or make TUIs a GUI? Why are those thin visual lines graphical, if the slightly thicker visual lines drawn by your graphical terminal emulator with support arbitrary color precision and inline image rendition is not? Maybe the issue is that it there is a terminal emulator to visualize the representation. But if an application that is not graphically heavy and needs an intermediary is a TUI, does that

The people who actually make immediate mode GUIs disagree with you. https://github.com/ocornut/imgui/wiki/About-the-IMGUI-paradi...

It's a trade off. With ImGui you can definitely have a GUI that is: 1. Very complex 2. Able to use custom, complex widgets 3. High performance 4. Written very quickly with a very simple API Those are significant pros. There are a few serious downsides as well: 1. It is not remotely conforming to the platform's standard UI (a bit less a problem for a DAW since they all have custom GUIs and widgets anyway) 2. The font rendering is done by the GPU using cached textures, so it's more limited in terms of what you can achieve there (not so much a problem for DAWs because you don't have much text to display) 3. Power usage can be high unless you use tricks to adjust the frame rate dynamically 4. It's in C++, which can be a con for some people (although it's written in old-school C-like style) If you can live with those, it's a