
Show HN: Qt binding for Go with support for all major operating systems - therecipe
https://therecipe.github.io/qt
======
merricksb
This was heavily discussed 5 months ago:

[https://news.ycombinator.com/item?id=12928526](https://news.ycombinator.com/item?id=12928526)

------
overgard
I'm a bit confused by the docker part and emphasis on deployment. Is that just
for contributors/early adopters because theres no release yet, or is that just
part of the flow of using this?

~~~
therecipe
It depends on how much you want to embrace docker. In general you can use this
binding without touching docker at all. But if you want, you can use docker in
every step of the process. It starts with the minimal setup that just depends
on Go + Docker. Then continues during development, so if you would want for
example test your application on android really quick, then you would just
need to pull the android image instead of setting up the android SDK, NDK and
JDK by yourself. And then in the end you can use docker for your CI and CD
processes as well. For example by creating your own docker images on top of
provided ones.

------
farrisbris
I've been using c++/Qt for quite some time now, but i really prefer to work in
go. Feels like i'm a lot more productive while writing, and i don't have to
spend doubledigit minutes waiting for stuff to compile.

I recently stumbled over this project and have been using it quite a lot
since. It works really well and coming from Qt-land it was really easy to use
the provided bindings and generate the 'classes' for signals/slots. AND the
docker images are great for cross compilation. They just work :). Thank you so
much for working on this.

~~~
ball_of_lint
I recently tried out gold linker in a c++/qt project, and it nearly halved my
compile time. I don't quite have incremental linking working yet, but I expect
it to be even better.

------
pbnjay
I'm curious how this affects file sizes? I like my static binaries and
portability, but I fear this would make things balloon quite a bit to get the
same broad distribution.

I've been planning on using an embedded webkit + html app in an upcoming
desktop project. Are there any resources for how difficult it would be to
learn Qt and create a reasonable portable, easily downloadable app?

~~~
therecipe
The file size depends on the target and what modules you use, for dynamically
linked projects I would guess it's around 50mb for an average project. Maybe
20mb more on windows because of the icu libs, but those can be replaced with
your own (much smaller) versions. Static projects may weight half of what the
dynamic ones do, so maybe around 25mb. But depending on how much you care
about file size, you could also compile your own static Qt version and then
strip everything that you don't need.

Here [1] are some infos about QML development and here [2] you can try out QML
in the browser.

[1] [https://github.com/Esri/arcgis-appstudio-
samples/wiki/Unders...](https://github.com/Esri/arcgis-appstudio-
samples/wiki/Understanding-QML-Javascript-for-Web-Developers) [2]
[https://qmlweb.github.io](https://qmlweb.github.io)

------
cridenour
Have used it and hang out in the Gophers slack channel. You provide great
support and when I followed instructions it worked perfect!

~~~
therecipe
thank you :)

------
dejv
I am confused by QT licensing model. What are limitation of free QT plan used
by commercial (downloadable) application?

~~~
slavik81
The open source version of Qt is LGPL, which basically means you may use it in
a proprietary application if you use dynamic linking. If you link statically
or copy any of its code, then your program must be free software (GPL).

If you pay for a commercial license, you can link statically without
restriction. The commercial version is also necessary for locked-down
platforms like iOS where the dynamic linking can't be changed by the end user
of the software.

IANAL, and there are a few details I glossed over, but that's the simple
version.

~~~
hurd
"If you link statically or copy any of its code, then your program must be
free software (GPL)." I don't the first part is true (the second one is
though).

[https://www.gnu.org/licenses/gpl-
faq.en.html#LGPLStaticVsDyn...](https://www.gnu.org/licenses/gpl-
faq.en.html#LGPLStaticVsDynamic)

~~~
slavik81
The second part isn't technically true either. You can copy code without
requiring a license if you meet the requirements for fair use. For example,
copying function signatures for interoperability.

I was trying to be conservative and paint a simplified picture of the license
that you can't go wrong by following, but I definitely erred in leaving out
some possibilities and presenting it as if they don't exist.

------
01walid
dumb question: will qtdeploy produce a single static binary for the whole app
or is about some other sort of shared libraries deployment ?

~~~
learc83
I may be remembering wrong. But I believe back when I used Qt a few years ago,
the most common interpretation of the GPL license the free version used
prevented you from deploying with a single static binary.

~~~
e12e
Surely, that's "prevent you from deploying with a single static binary
_unless_ under the GPL/binding offer of source code"?

~~~
hellofunk
You can technically deploy with a static linked Qt as long as you provide your
compiled object files for download somewhere along with instructions for how
to swap out the linked Qt with any other version of Qt. This keeps your code
proprietary and honors the license.

For example, you must deploy as a static linked Qt on the Apple App Store, but
since Xcode is free and no Apple dev account is needed to install an app on
your iOS device, you can provide instructions for how any user could install
your binaries with any version of Qt. Unlikely any user would ever do this,
but by making the process publicly known, you honor the license (and you don't
need to share your own source code).

~~~
e12e
Xcode might be without any cost, but the Apple hardware needed to legally run
a copy of OS X (which also isn't free) - I don't really see how "Xcode being
free" enters into it, as long as the software is distributed for iOS devices?

For the Mac app store, it might be different, as you need a Mac to access that
anyway.

FWIW I think the issue here is that artificial limits on what code can be run
on what hardware (legally) is in conflict with the (L)GPL -- and there's
really nothing anyone other than Apple can do about it. Which is also why, as
far as I know there's no actual legal way to distribute (L)GPL software on
these locked app stores - there's no way for the distributor to actually honor
the license, and so no way for them to be able to (re)use/distribute the code
legally?

------
educar
Why is the -fast flag not the default for qtdeploy?

Edit: er, why the downvotes for a harmless question? I was curious why a flag
named fast is not the default. This question is also very much related to the
project page linked.

~~~
therecipe
qtdeploy is intended to be used for deploying and therefore will run qtrcc,
qtmoc, qtminimal and do the actual bundling of your binary. the -fast flag re-
uses the cached rcc_* moc_* minimal-* files and will also not re-run the
actual bundling process. this works for the desktop targets but not for the
mobile targets, therefore I made it optional.

------
pspeter3
Does this require CGo?

~~~
TheDong
Yes. For example, the dbus package:
[https://github.com/therecipe/qt/blob/053d54a2eb0658bae6e3259...](https://github.com/therecipe/qt/blob/053d54a2eb0658bae6e32597a276af4245d10806/dbus/dbus.go#L5-L17)

[https://github.com/therecipe/qt/blob/053d54a2eb0658bae6e3259...](https://github.com/therecipe/qt/blob/053d54a2eb0658bae6e32597a276af4245d10806/dbus/dbus.cpp)

All of the code is cgo wrappers around messes of c/c++

~~~
infogulch
Can gc load a cgo plugin [1]? If so, could you build therecipe/qt into a
plugin and load it at runtime to avoid being forced to use cgo?

E.g. your project has `type Qt interface {`, and the plugin exports a global
symbol that can be asserted to that interface to use the library.

[1]: [https://golang.org/pkg/plugin/](https://golang.org/pkg/plugin/)

~~~
therecipe
It could probably work, but plugins currently only work on linux.

------
edwinyzh
I also prefer golang over c++ for simplicity. But does it have IDE support? I
mean Qt Creator. In the meantime, my first choice for cross-platform GUI
development is Lazarus - clean language, broad OS support, and full IDE
support (drag-and-drop layout designing and integrated debugging).

~~~
GoodbyeEarl
Sorry for the newbie question, I've never written a desktop application. But
do you write the UI in a different language than you write its business logic?
For instance, you would write the UI in Delphi with the Lazarus IDE and then
the "back-end" of your app would be written in C++, Go or something alike?

~~~
uvatbc
tl;dr: sometimes the UI can be written in a different language.

Qt used to have an XML markup language that auto generated C++ UI code.

Later, QML was introduced - which is a JavaScript based UI runtime.

There are Qt bindings for other languages, for example Python. So you could
write business logic in Python and UI in QML.

~~~
GoodbyeEarl
Thanks! So is Qt used to write both the logic and the UI?

------
eberkund
Does this work on embedded devices without desktop environment?

~~~
therecipe
If Qt supports it, then you can probably get it working with this binding as
well.

~~~
niccl
IS a beaglebone black sufficiently close to a raspberry pi3 that I can use the
RPI3 environment for beaglebone black dev? If not, what's required to
implement on a new platform?

~~~
therecipe
I think you can't simply reuse the rpi3 env, but you can use it as a template
to how to get this working for the beaglebone black. So you would need to get
a cross compiler and then extract the sysroot to compile Qt on your own. After
you got Qt compiled, you will also need to make some changes similar to these
[1] But I think the hardest part might be to get Qt compiled for the
beaglebone black, because the info I found online seems to be a bit outdated.

[https://github.com/therecipe/qt/pull/226/files](https://github.com/therecipe/qt/pull/226/files)

------
mike_ivanov
Is the wrapper C++ code generated or hand-written?

~~~
therecipe
it's automatically generated against the Qt version you use when you run the
setup. the generator is also used to power qtmoc and qtminimal.

~~~
mike_ivanov
To clarify myself, I wondered if the _wrapper_ code is generated (like here
[https://github.com/therecipe/qt/blob/master/websockets/webso...](https://github.com/therecipe/qt/blob/master/websockets/websockets.cpp)),
not the moc-generated code.

~~~
therecipe
yes, the _.cpp_.h and *.go files are all generated

------
gwenzek
what are the differences with go-qml? [https://github.com/go-
qml/qml/blob/v1/README.md](https://github.com/go-qml/qml/blob/v1/README.md)

~~~
therecipe
go-qml, like the name suggests allows you to use QML together with Go. This
binding allows you to also use Qt's C++ API. And it contains some tools to
simplify deployment and development processes.

~~~
AsyncAwait
Just wanted to say, thanks for working on this! :-)

~~~
therecipe
:)

------
golem14
Nice to see this happening.

FYI, the 'examples' link on that page is broken

~~~
homarp
it works from the README on github and goes to
[https://github.com/therecipe/qt/tree/master/internal/example...](https://github.com/therecipe/qt/tree/master/internal/examples)

------
znpy
Is this an official package?

~~~
therecipe
no

------
kingmanaz
I would be nice if Google put resources behind a project like this. Same with
gopherjs.

