Ideas for a brand new widget toolkit

[Ramon]

I suggest to first find out what we really want (and therefore 
who "we" is).

It seems to me that there are basically 3 groups:

- looking for some kind of GUI-kit that is less massive than gtk, 
qt, etc. and runs pretty everywhere.
   Need addressed: Well, sometimes a GUI is needed. A no frills 
basic thingy will do; most importantly it must run everywhere and 
more or less feel like the native GUI.
   One approach: D'ize Fox

- Looking for sophisticated GUI, possibly mainly for games, video 
etc.
   Need addressed: Graphics intense applications. Speed is 
important.

- Add a GUI toolkit to D
   Need addressed: D should have a GUI toolkit anyway. Why not 
create a major one and do it a) the D way and b) properly, 
possibly attracting more users to D?


Some remarks in no special order:

- Doing something HTML (ideally 5) based looks very attractive 
and cross plattform. It brings with it, however, either the need 
for a built in http server and the interface app/server - or - an 
HTML component which again needed  obe based on some GUI kit.

- Whatever we come up with should use native controls where 
existing and otherwise simulate them using other more basic 
native controls.
This sounds ugly, can, however, actually be a major chance and 
interesting approach.

- Simply creating yet another GTK or QT is unattractive - they 
already exist and so do bindings to D (if I'm not mistaken. 
Otherwise those bindings can be created)

- We should avoid some errors made by others and prepare for 
environmental changes (like X possibly being replace by wayland).

In summary I'd consider to create
- something new (rather than creating a, say, fox binding)
- that starts simple, already addressing many needs
- is designed in a way as to allow for some unobtrusive http 
binding (meaning: usually it runs by itself but it *can* - 
without breaking ones arm - also work through http)
- is based on a clearly defined set of basic widgets that are 
commonly available in all major targets (X, Windows, mac, 
possibly android, etc)
- is designed in a modular way so as to provide a) a basic GUI 
kit and b) - optionally - extensions or a "large" kit version. 
Reasoning: in 80% of cases a gui is needed simply as a gui 
interface for whatever programm. Sometimes, though, more is 
needed like e.g. a video widget.
This a) eases design and development and b) is attractive because 
pretty every existing solution is either smallish (often too 
small) or a monster (often way to big)
- could, in the long run, offer an HTML component so as to make 
HTML targets self hosting yet keep the http option open for new 
operating systems.

My first target would be something like "designing a new 'fox' 
fully using D's superior capabilities and doing that along the 
lines I listed above".

In other words: Let's scratch some itching that is a) common and 
b) not yet properly addressed by what is available.

regards - Ramon