
Go + gxui: Rendering native app GUIs on any platform? - wakaflockafliz
https://github.com/google/gxui/issues/49#issuecomment-113700372
======
jalfresi
I've not tried this but I thought I'd mention that I've been using the QT QML
packages for building desktops apps and the results are amazing!

[https://github.com/go-qml/qml](https://github.com/go-qml/qml)

Even better with the Material additions from here:

[https://github.com/papyros/qml-material](https://github.com/papyros/qml-
material)

Building Google Material themed apps easily with a Golang back end? Lovely!

I really hope the Golang team are considering the QML package as part of the
standard library in Go v2, it would an absolutely awesome GUI kit to have as
standard!

~~~
fla
Qt is an amazing framework which got many things right!

The combo C++ QML QtQuick made my life so much easier for a cross-platform
OSX/Win app.

I was able to develop most of it on Linux, and it even looks nifty!

What else can you wish ? :)

~~~
cm3
I also prefer Qt but starting with Qt4 it imposes a minimum memory overhead of
25MiB to 30MiB for even a simple single window application with nothing in it.
QML is likely higher. I don't like Gtk3 but they don't have this particular
disadvantage. It's too much overhead and I haven't found a fix.

~~~
fla
Yes that's one of the downside. Also, the binaries can get fat really quick.
Especially when you link statically with some of the Qt components.

I guess it's a fair trade-off when you target today's desktop systems.
Otherwise, it might worth looking at Qt for Embedded Linux.

------
ctoth
I was excited to see "native" UI -- which I read as using the specific OS APIs
to create native controls.

This instead seems to be taking the Kivy OpenGL controls approach. It looks
very nifty and as though it took effort by some smart folks.

I was only hoping for truly native controls so as to provide access to screen
readers and other a11y solutions by default.

------
franciscop
> "This is so figgin cool, I woke up my wife this morning and showed her. She
> had no idea what she was looking at, but I know she recognized it as figgin
> cool as I'd normally get punched for waking her that early on a Saturday."

------
roel_v
How is this a 'native app GUI'? It's only OpenGL as far as I can tell?

~~~
laumars
OpenGL is native. I assume you're thinking of the native WIMP APIs such as
Win32, Cocoa, and so forth. But OpenGL does run natively on the client OS -
even if the widgets then have to be re-implemented.

~~~
roel_v
For 20 years, 'native GUI' has meant 'using the system's toolkit', not
'doesn't use web page to half-ass impersonate local application'. If this is
really only OpenGL, then a more apt title would be 'Go + gxui: Rendering
triangles very fast on any platform?'. There is quite a gap (like, Grand
Canyon sized gap) between 'able to render what OpenGL provides' and 'render
GUI'. Even building a UI as primitive as Motif is many man-months of effort
for any serious application, if all you have to work with is OpenGL.

~~~
laumars
I don't think anyone has ever said "native GUI" in the last 20 years. It's
pretty nonsensical if you actually break down that passage to it's core
components because it doesn't actually describe what specifically is "native":

\- the libraries? But that's a programming interface for drawing graphics, not
itself a graphical interface.

\- the aesthetics of the widgets? This would be a more accurate
interpretation, but the problem with that interpretation is that you could
design web pages to look like Win32 forms and people widely consider HTML
applications to be native.

\- the layers of abstraction between your code and the rendering of your user
interface? What about people who use .NET, MVC's or other wrappers?

\- the author of the toolkits (eg MS toolkits for Windows, Apple for OS X)? So
would that mean there's no native Linux GUI's because Linus Torvalds hasn't
written any Linux widget libraries?

Saying "native GUI" doesn't really describe your point. Which is why I made
the distinction between _widget reimplementation being drawn natively on the
OS_ vs _widgets being drawn via Microsoft or Apples own APIs_. This project
being the former and your point being the latter - both being native in their
own way yet different in their details.

~~~
coldtea
> _I don 't think anyone has ever said "native GUI" in the last 20 years. It's
> pretty nonsensical if you actually break down that passage to it's core
> components because it doesn't actually describe what specifically is
> "native"_

They have, and they have said it exactly as the parent mentions.

See for example complaints about webkit based apps not looking and behaving
native on iOS, and similar complaints for all kinds of desktop apps using some
third party toolkit: from Eclipse and Firefox to Opera (when it used to do
that) and GIMP on OS X, anything Swing.

> _it doesn 't actually describe what specifically is "native"_

It's pretty much agreed what's native is the specific, OS-based (or user-
chosen-toolkit-based on Linux) implementation of widgets and controls, as it
pertains to both look and feel.

There are even whole terms often associated with such complaints, such as
"uncanny valley" etc.

> _So would that mean there 's no native Linux GUI's because Linus Torvalds
> hasn't written any Linux widget libraries?_

No, for a Gnome user, non native is anything non Gnome (GTK). For a KDE user
anything non KDE. But the analogy is not perfect, because Linux doesn't come
with a pre-built specific GUI lib for all users, so users are accustomed to a
hodgepodge of varying behaving and looking apps to serve all their needs
anyway, with some sugar of cooperation for things like drag and drop on top.

------
wakaflockafliz
Please forgive me if the title isn't 100% accurate. After thinking about it,
this possibility of combining both native and web view rendering seems like it
could be an interesting approach for a wide variety of potential use-cases.

Are there any nice tools out there for creating apps that render to both
native + web?

~~~
overlord_tm
Create HTML app and pack it in some kind of shell (chromium embeeded, atom
shell, nodewebkit)?

------
atomical
It is truly ugly. I say that out of wishing that they had designed it
differently.

------
jayfk
404?

------
innguest
First of all, these are not OS-native to any OS I know. So it's not native
GUI. "Native" refers to the OS, not to the hardware.

Second, the GUI looks atrocious. What is wrong with designers nowadays that
they think we live in a cartoonish world?

