
Qt Design Studio 1.0 - conductor
https://blog.qt.io/blog/2018/10/25/qt-design-studio-1-0-released/
======
nicodjimenez
Awesome marketing video for an under hyped product!

My startup abandoned .NET in favor of Qt to develop a cross platform
screenshot app to digitize math equations because we wanted Linux support
([https://mathpix.com](https://mathpix.com)) and it's delivered. We still use
Swift for our Mac app. The thing about .NET is that it's not nearly as
seamless as a development stack as Swift + the whole Mac ecosystem. Whatever
clunkiness exists in Qt apps already exists 10x in the Windows ecosystem of
clunkiness everywhere, because Windows itself is, in a sense, cross platform.
So the difference between a Qt app a .NET app is not super noticeable on
Windows.

A good Qt app will be very nearly as good as a good .NET app, and a good Swift
app on MacOS beats them all by a landslide.

~~~
IloveHN84
You are comparing potatoes with tomatoes.

Swift is developed by Apple for Apple ecosystem. Thus, the native calls are of
course efficient.

Qt is a framework that works as bridge between the native calls and your
application, the same applies for .NET.

If you develop on windows with WPF/MFC/Win32 calls, it will be obviously
faster than Qt, because you're saving on that bridge calls.

Why don't you use Qt on Mac then? The main advantage of using such a framework
is that you have only one codebase/language that runs everywhere.

~~~
vetinari
MFC is a layer above Win32. So is Qt, except with better design and
maintained.

WPF is somewhere else; as the sibling commenter told you, it is a .Net
framework, so it has entire .Net VM underneath.

~~~
badsectoracula
> MFC is a layer above Win32

Not exactly and this view of it is IMO why a lot of people dislike it: MFC is
not a layer like Qt, you don't use it to avoid Win32, you use it to _enhance_
Win32. When using MFC you need to know both MFC and Win32 and you use both of
them at the same time. On the other hand when you use Qt you can ignore
anything related to Win32 because the Qt API layers itself over whatever is
below.

Of course this has several implications, starting with that if you don't like
Win32 then you wont like MFC either (and the reverse isn't necessarily true -
you may dislike MFC while liking Win32).

------
Keyframe
My impression is that tools, over the last few years and no matter the stack
they're for, have kind of converged onto where Flash was eons ago. Remember
when web was littered with 2advanced clones? Looks like we've abandoned Flash,
but never gave up the idea.

~~~
sdegutis
Qt seems to have a very strong niche market share, but to this day I still
can't tell exactly who is using out commercially outside of maybe a few bigger
name Linux utilities.

~~~
jcelerier
> but to this day I still can't tell exactly who is using out commercially
> outside of maybe a few bigger name Linux utilities.

Microsoft OneDrive is made with Qt, the Blizzard launcher, the AMD drivers
panel, authoring software like Guitar Pro, Maya, CryEngine, Allegorithmic
software (one of the slickiest UIs in that field I think :
[https://www.allegorithmic.com/](https://www.allegorithmic.com/))...
Blackberry also used Qt for their OS's shell and apps, as well as HP/LG WebOS.

------
RyLuke
If you're interested in this sort of thing (design-oriented IDEs targeting
runtimes/frameworks), there are a few other similar tools:

\+ Rightware Kanzi
([https://www.rightware.com/kanzi](https://www.rightware.com/kanzi))

\+ DiSTI GL Studio ([https://www.disti.com/user-interface/gl-
studio/](https://www.disti.com/user-interface/gl-studio/))

\+ Altia ([https://www.altia.com/](https://www.altia.com/))

Most of them have found niche markets in verticals like
automotive/medical/embedded, where it's easier to just ship a runtime for the
UI.

UI/UX designers working on the dominant platforms (web/mobile) have a lot of
nostalgia for Flash--particularly the perceived ability to actually ship
functioning product. There's no lack of new tools trying to improve on the
status quo: drawing pictures of UI and throwing them over the wall for
developers to figure out how to implement.

I suspect that we haven't seen the aforementioned IDEs become industry
standard for a couple reasons:

\+ They're by nature more difficult to use than drawing tools, often surfacing
a lot of advanced parameters, state machines, and code

\+ The variability in languages/frameworks/platforms inherent in web and
native development make usable output a much harder problem than having
everyone all-in on a single framework/runtime

~~~
pjmlp
\+ They are mostly commercial and a large set of Web developers are allergic
to pay for tools.

[https://www.adobe.com/products/animate.html](https://www.adobe.com/products/animate.html)

[https://www.outsystems.com/](https://www.outsystems.com/)

[https://webflow.com/](https://webflow.com/)

[https://www.fluidui.com/](https://www.fluidui.com/)

------
Multicomp
Good looking piece of software.

I know QT is this big powerful thing, but where does this fit in compared to
QtQuick/QML/QtCreator and so on? My frame of reference is .NET desktop
development FWIW, but this looks like some cross between VS Blend and Adobe
Flash/Animate.

I'm pretty sure that is incorrect, can someone please enlighten me?

~~~
rhodysurf
Qt Widgets can be wired up graphically with QtDesigner but AFAIK that program
does not work with QML, which is basically modern Qt.

So this looks like a design tool for creating QML interfaces. The animation
parts come in because QML allows for embedding javascript so you can probably
do all of that graphically now and get QML code out

~~~
joezydeco
Yeah, this is just another step closer to the holy grail of letting Photoshop
users create live UIs out of mockups.

Hooking QML into actually doing something useful? That's a whole different can
of worms.

~~~
berti
Qt's signal/slot mechanism coupled with it's model framework make it quite
simple to wire a QML GUI to a C++ backend.

------
emmanueloga_
So QML and QT design tools are awesome! I think nothing matches the
capabilities of this platform.

Still, each time I think of using QT I get discouraged (a bit) by the
licensing (even though there's almost zero chance I'll ever independently sell
a software product! :-p).

In paper, one should be able to use the community version of QT for commercial
software, but it looks like actually doing this could be really tricky [1].
And the commercial license is so expensive! QT page says: "Pricing starts at
$459/mo." :-O.

1: [https://www.quora.com/Can-I-use-the-free-QT-
for-c++-commerci...](https://www.quora.com/Can-I-use-the-free-QT-
for-c++-commercially)

~~~
irishcoffee
Qt is lgpl. Unless I missed something, this should not be a problem whatsoever
if you'd like to use the Qt framework and sell commercial software.

~~~
mrpippy
Specifically, LGPL3 since Qt 5.7. Big problem for people making embedded
devices, but shouldn’t be for commercial software.

~~~
exikyut
If the embedded device supports dynamically linked libraries, though, that
could still work

~~~
joezydeco
As long as you can deliver the toolchain used to build the libraries, _and_
allow the finished libraries to be installed on your target hardware over the
current ones.

I know one major vehicle manufacturer that won't go past 5.6 because of this
reason. They put it right in the RFP.

~~~
reitanqild
Edit: I might be misunderstanding something here but:

I'd think a major vehicle manufacturer should be able to pay for the
commercial license?

~~~
joezydeco
Has nothing to do about the royalty fees. Those didn’t change from 5.6 to 5.7.
It has everything to do with being required to allow end customers to install
their own libraries on a piece of their machinery. LGPL 3 closed the LGPL 2.1
loophole concerning this.

The legal and warranty issues around letting customers reflash their
dashboards are what the company wants to avoid.

~~~
reitanqild
But I thought that was part of what you got with the commercial license, a
right to use it without adhering to the open source license?

~~~
joezydeco
Yeah, that does kind of point to avoiding the royalty, doesn't it?

~~~
reitanqild
So we agree then, they are being cheap and the part about the license is just
an excuse?

------
electricslpnsld
Looks like this is mainly QtQuick? Has anyone had success getting platform
native-(ish) looking and behaving Desktop applications working in QtQuick? I
have a few applications running on QWidgets which I'd like to port over for
performance reasons (QWidgets has known performance problems on high-DPI Apple
platforms they probably won't ever fix), but QtQuick apps tend to behave like
off-brand tablet apps, out of the box.

~~~
alien1993
You could use Quick Controls 2, they can be styled easily.
[http://doc.qt.io/qt-5/qtquickcontrols2-index.html](http://doc.qt.io/qt-5/qtquickcontrols2-index.html)

~~~
jcelerier
There is a Quick Controls 2 style that uses the Qt Widget looks :
[https://github.com/KDE/qqc2-desktop-
style](https://github.com/KDE/qqc2-desktop-style)

------
sktrdie
Why can't we have this for the web? :(

~~~
panic
In order to have native-quality text editing on the web, you need to use the
DOM. Using the DOM limits what kind of UI you can have.

~~~
CyberDildonics
I don't see how that makes any sense at all. What is the actual limiting
factor?

~~~
slededit
That's actually the limiting factor, otherwise you could just compile Qt to
WASM and draw to a canvas.

To render text nicely you need to know the geometry of the screen so you can
anti-alias properly. A canvas goes through a series of transforms that work
fine for images but garble text.

~~~
panic
The look of the text is just the tip of the iceberg. Many text editing
operations are tightly integrated with the operating system and impossible to
implement without an editable element. For example, on recent iPads you can
move the cursor around by swiping the keyboard with two fingers. I don't know
how you'd support this gesture without creating an actual editable element on
the page.

------
pier25
This new version of Flash Pro is looking great!

Oh wait...

~~~
vturner
Everything old is new again

~~~
jcelerier
to be fair Qt Designer has been around since 2000 :p

------
pzo
Does anyone have experience if it is currently possible to use QT open source
license for commercial iOS app distributed on App Store? People seems divided
about that.

------
sxp62000
What is Qt? Can someone explain it like i'm 5? The video in that blog post
makes it look really scary!

~~~
gmueckl
Qt is a set of interoperating libraries for the development of cross-platform
graphical applications. It covers a lot of topics from abstracting basis
operating system services to various ways to create the actual UI (with
traditional widget hierarchies instantiated in C++ code, declaratively using
QML...) and advanced features like embedded webkit or interfacing with OpenGL
or Vulkan.

The library has two core strengths: it works on virtually every platform that
can run a GUI and the application code can be made to be pretty much agnostic
of the underlying OS. Unless an application uses OS interfaces directly for
fancy things, most of the porting work is just recompiling the code.

~~~
sxp62000
I noticed on the Qt website that it's used in everything from car dashboards
to coffee machine interfaces. Is there a special reason for this? Is Qt hard
to get into?

~~~
gmueckl
It is used for even more than that. KDE, the Linux desktop environment with
its huge set of applications has used Qt since its early releases in the 90s.
There is also a large set of commercial desktop applications for Windows and
macOS that use Qt. That Qt is used for embedded software UIs is a comparably
recent development in its long history.

I think the reason for this is that Qt has extremely high quality widgets and
graphical elements. They allow you to do things out of the box that would be
crazy hacks with most of the competitors. And the options for styling the UIs
are very good, too, which matters a lot for these embedded use cases.

Is Qt hard to get into? Yes and no. In C++, you are required to use some
mechanisms like signals/slots, which are used for routing events. These
features look like non-standard language extensions and rely on a special
source code preprocessor to generate the glue code that is implied. The other
concepts are easier to pick up. And the toolkit is very consistent in the
structure of its interfaces, so once you pick up the patterns, you can get
very productive.

~~~
sxp62000
Great answer! Thank you!

------
bun_at_work
> an effective workflow fosters and _boosts_ product innovation

Is there a way to use this without Boost?

~~~
mrfredward
You only have to include one hpp and use the Boost::ProductInnovation
namespace. It's easy and the installer will only use a quarter of your hdd.

------
qwerty456127
Any tutorial on building a cross-platform (Linux, Mac, Windows) desktop GUI
app with this?

~~~
irishcoffee
I think you just write qt, it's already cross-platform.

~~~
qwerty456127
Well, Ok, I mean any good tutorial on making a desktop app with Qt Design
Studio. I expected it to be something like a better Qt Designer which is
reasonably intuitive to use but in the video it looks completely
extraterrestrial although beautiful. I'd like to build a desktop app with it
but don't feel like I have any idea about how. The only tutorial video easy to
find shows "Building an Instrument Cluster for Your Car HMI" and doesn't seem
to make it clear how is the app supposed to interact with the computer it is
ran on. Is it for cars only? Is it not supposed to be used for desktop apps
development?

~~~
Elv13
The old QtDesigner was simple enough. If you want to create classic desktop
applications, use it.

QML is closer to a game engine than a widget toolkit. It is intended to
provide an easy way to animate everything and create custom looks. It feel
alien for a few months before you "get it". It _is_ very powerful and easy to
use, but the learning curve is steep and when you hit the limitations of the
framework, have fun making any progress beyond it. It's also a bit hostile to
native and modern code. Shared pointers are ignored and crashy. The binding
between C++ and QML is also not the fastest thing in the universe.

I am writing complex apps using both as my bread and butter. I would not
recommend QML for quick prototyping of complex apps. QtDesigner/QtWidgets
still beat it. However if you need touch or fluid and modern looking GUI,
QtWidget is a dead end and QML/QtStudio shine. It's really a project per
project choice. They fill different niches.

~~~
qwerty456127
Isn't it convenient to develop the whole app GUI in QML/QtStudio and use HTTPS
to communicate to a backend without using any kind of pointers (ever since
I've been coding C and C++ many ears ago when I was a schoolboy, the word
"pointer" scares the shit out of me %-)) or something like that? In fact my
whole experience is about C#/WinForms and I'm thinking about what modern
cross-platform GUI toolkit that is probably going to be relevant in future and
more pleasure than pain to use should I possibly switch to. I am also
interested in developing KDE5 desktop widgets ("plasmoids") which are to be
written in QML AFAIK.

~~~
Elv13
(disclaimer: I am a sponsored KDE5/KF5 dev)

> Isn't it convenient to develop the whole app GUI in QML/QtStudio and use
> HTTPS to communicate to a backend without using any kind of pointers

It /can/ be done, but almost nobody uses Qt that way. The web stack is a
better fit for this. Pointers are not scary. Alsmost all languages these days
use pointer (object reference) by default and it scares no one. Qt doesn't mix
pointers with scoped/std::move in the default API, so you wont shoot yourself
in the foot by accident. QObject, the base C++ class of every Qt component is
reflected into the QML vm automatically, so you can use your objects on both
side without any overhead or synchonization. You just need to add the
`Q_PROPERTY` and `Q_INVOKABLE` macro in your header and QML will see it.

> Isn't it convenient to develop the whole app GUI in QtStudio

I honestly still think that's impossible. QtStudio isn't (yet?) close be being
a good IDE. It aims at closing the gap between designers and coders. For pure
coders, writing QML by hand is more predictable.

