Evolving THE GUI definition? Please chim-in with views or ideas to sort things out, correct or add. Are we already further, or yet not here at all?:
What's needed? With many platforms and gui toolkits around, it seems they all have their basic platform- and toolkit specific way, often the nitty-gritty way. These ways evolve from the constraints of the specific projects. Choosen paths and specific features. Whereas, the constraints of application developers may many? times let them to wanting something different. A most simple yet powerful and elegant way to write logic and and easily getting, adjusting, or (re)definig their GUI. What's the big (i)deal? A straight-forward way to code, while getting good GUIs with a native interface on each platform (a basic GUI even automatically), without any external dependencies. Of course with the option to refine widgets, or mixing-in elements defined by an arbitrary selected other toolkit (or even mixing different toolkits)? Immediate mode? Canvas-in-canvas? What I found for Nim: 1. Cross-platform native interfaces (for desktops) can be created with NiGui (<https://github.com/simonkrauter/NiGui>). However, native android, iOS, and HTML interfaces have been postponed until finding a way for a common event system for various toolkits (<https://github.com/simonkrauter/NiGui/issues/11>). 2. Some gui libraries have already evolved some improved ways to define interfaces (and events) to different degrees, e.g.: * Fidget (halted in favor for v2): adding declarative nim featurues (dsl) that can be used within regular nim code structures, simple enough to allow "code from graphics" (external graphical canvas generator/editor). Exposes linear re-calls, instead of callback chains. No native interfaces, though. * Fidgetty (ongoing fork of Fidget v1): Adding widgets and theming to Fidget. * WebGui: Can it be used as the HTML backend, to create widgets in browsers (like <https://github.com/rawpython/remi> can be used by PySimpleGUI) * Qt Creator plus NimQML seem to cover a whole lot, but not HTML, and seem to introduce Q(t)isms into the calling code, and create large dependencies. Also qt does not seem to compile to in-browser js. * Maybe authors/more advanced users can comment on how well they would want to get, or fit into, an integration. 3. Nim features nice ways to abstract things into smooth solutions. 4. There is a spectrum between applications with the need to actively develop a (custom) GUI, to applications (tools) can start working already with GUIs that are automatically generated from regular code, or CLI-features/helpers. Customizing as required. What do do? The challenge at hand seems to be, to unite things into a nim "specification" for default widgets, widget customizations, toolkit selection, and theming. Separating concerns with an eye on working with a shared nim interface. How? Planning a joint effort? Allow application coders to select their default toolkit, and add their optional customizations, which can draw GUI elements as native-widget/some-toolkit-widget/custom-or-pure-figment-sprites?? Has Fidget already come reasonable close to finding some "common event system" logic that works for input/output of events from different toolkits (<https://github.com/simonkrauter/NiGui/issues/11>)? Is the only thing left for an integration, to add access to native interfaces (i.e. NiGui and webgui) to Fidget v1 or v2? Or the other way around? A NiGui based (native interface) abstraction that can setup spaces to call other toolkits to draw their widgets within? Other's Work? (at least some notable pointers) Multi-backend, simple switch between Tk,Qt,HTML. (<https://github.com/PySimpleGUI/PySimpleGUI>) "Markup"-like custom GUI code, that's already visually recognizable in the code (wysiwyg ;-). (<https://github.com/alfiopuglisi/guietta/>) Default automatic (or "implicit") GUI, based on argparse interpretation and an optional annotation. (<https://github.com/chriskiehl/Gooey>) Default automatic CLI, even without any argparse helper: Automatic argument parsing, and validation, CLI-option documentation, as well as function execution, simply by adding commented variable and function definitions. (<https://github.com/TangoMan75/shoe>)
