Tuukka Turunen

Qt Roadmap for 2019

Published Friday February 22nd, 2019
54 Comments on Qt Roadmap for 2019
Posted in Biz Circuit & Dev Loop, Qt, Roadmap

It has been a great start into 2019! We recently released Qt 5.12 which comes with multiple performance improvements and thousands of bug fixes– it’s a great release to base your work upon. But we have more in the works: Python language bindings, tools for developers and designers, industry-specific offering, and a lot more. Indeed, 2019 looks to be another great year for Qt users!

It’s around this time of the year I sit down to write a blog post about our plans and roadmap for the coming year. Typically, some of the items have already been cooking for a while, but some are still plans in the making. If you want to look into the previous roadmap blog posts, here are the ones I wrote for 20162017 and 2018. There is always more to tell than what would reasonably fit in a blog post, but I’ll try to talk about the most interesting items.

Before diving any further into the new items planned for 2019, I would like to thank each and every Qt developer for their contribution. We have a great ecosystem with many contributors who have provided multiple extremely valuable contributions throughout the years and continue to shape Qt in the future, too. In addition to those contributing code, we also have many active people in the Qt Project forums, on mailing lists, as well as reviewing code and testing the Qt development releases.

The Baseline: Qt 5.12 LTS

A lot of our efforts in 2019 will go into further improving Qt 5.12 LTS via multiple patch releases providing error corrections and performance improvements. Qt 5.12 LTS is the third long-term supported Qt 5 release and as such already a great baseline for developing applications. In Qt 5.12.0 we have fixed over 5000 bugs since Qt 5.6.3 and over 2000 since Qt 5.9.7. As all fixes currently go to Qt 5.12 LTS we take further steps ahead of the earlier LTS releases with each Qt 5.12 LTS patch release. In addition to fixing bugs and developing new features, we have put a lot of effort into improving performance and resource consumption of Qt applications – especially those using Qt Quick and Qt 3D Studio. Qt 5.12 LTS added several new features too, and contains all the cool features of earlier Qt 5.11 and Qt 5.10 releases since the previous LTS release of Qt.

With Qt 5.6 LTS support ending in March 2019 and Qt 5.9 LTS being in the Strict mode (receiving only the most important fixes) we advise migrating to Qt 5.12 LTS. Not only will your Qt application run faster and better thanks to the bug fixes and performance improvements, but you can also profit from the many new features and optimizations Qt 5.12 LTS comes with.

So, the baseline is solid, but 2019 is not going to be merely about bug fixes and polish – we have also many cool new things cooking. Read on for a brief overview of what you can expect to be released during 2019.

Python, WebAssembly and other new goodies

Qt now fully supports Python with Qt 5.12 LTS. A lot of work has been done to get to this point, and we are really pleased to put all of Qt’s functionality at the fingertips of the growing community of Python developers. The work continues throughout 2019 with improvements and new features. In addition to constantly improving the Python bindings and supporting all the new Qt versions and patch releases, we have some great new features planned for 2019.

One highly requested new feature is integration with commonly used Python 3rdparty modules like numpy, pytorch, pandas and matplotlib. Out of these, we expect to provide at least integration to numpy during 2019, possibly some others as well. Easier deployment of Qt for Python applications is another commonly requested item and we aim to provide a better solution in 2019. Other major items include improved integration of QML as well as tooling improvements, especially making Qt Creator an awesome IDE also for Python developers.

Another really cool new item is Qt for WebAssembly. It has so far been a technology preview but will become a fully supported platform with Qt 5.13. It has gained a lot more functionality, as well as performance and stability improvements since the first preview release. We continue to improve functionality and fix bugs as more users adopt Qt for WebAssembly and report issues.

2019 will bring a lot of important features and quality-of-life improvements to Qt for WebAssembly users. Windows will be supported as a development host, in addition to Mac and Linux which were already available. We also start providing binary packages of Qt for WebAssembly, just like we do for most of the other supported platforms. New features coming in 2019 include access to local file systems (with the restrictions imposed by the browser sandbox), threading support on browsers where this is enabled, support for system clipboard, and addressing multiple canvases in the browser document. We are also working to enable debugging and to improve linking times for applications to accelerate development.

With Qt 5.13 we are adding a technology preview of Qt Lottie, a player for Bodymovin animations. Bodymovin is a plugin to Adobe After Effects tool and there are multiple different player implementations on different platforms – and now a cross-platform one created with Qt. The new player allows easy inclusion and use of these animations in a Qt Quick application. Qt Lottie makes it possible to control the pre-created animation (reverse/start/pause/stop/autoplay etc) and even change the animation source dynamically. From the beginning, we have focused on performance aspects to enable Qt Lottie to be used on embedded devices in addition to the typical targets of these animations like web, desktop and mobile platforms.

While the functionality of Qt Widgets is already very comprehensive, we are also planning to add new widgets during 2019. Our current thinking is that a circular progress bar and a switch widget would be good additions. One of them or both should arrive at a computer near you with the Qt 5.14 release. Other than that, we are continuously working to improve Qt Widgets further by fixing bugs and making small improvements where needed.

Tools for Developers: Qt Creator and new Qt Lite Tooling

In the past releases of Qt Creator, we have done a lot of work behind the scenes to switch to the clang code model. Now that this is done, we have already enjoyed some benefits such as clang-tidy and clazy. During 2019 we plan on bringing better diagnostics management as well as improved performance to the Qt Creator IDE. One development item is to use a symbol database (indexdb) to have a fast, binary representation of the project. This is expected to improve performance a lot compared to parsing the files continuously. We are also improving the Language Server Protocol support and leveraging it to support more programming languages with Qt Creator.

The new framework items need good tools and thus we are continuously improving the Python support of Qt Creator to allow great developer experience. Currently just a research item, we might enable the ability to extend Qt Creator via Python in the future. We will update you on where this will lead us towards the latter part of 2019. We are also working to provide out-of-the-box support of Qt for WebAssembly.

CMake has been supported by Qt Creator for quite a while. During 2019, we aim to improve the support further and make it easier to start new projects with CMake. We plan to create a CMake based build system for Qt Creator and to better support embedded development with CMake using Qt Creator.

Qt Quick Designer, which is part of Qt Creator, will receive new functionality initially developed for Qt Design Studio. While Qt Design Studio is indented for designers, not directly as a development tool, it does share a lot of parts with the Qt Creator IDE. Thus, we can bring many of the usability and ergonomics improvements into Qt Creator’s Qt Quick Designer view. One major new feature coming soon to Qt Creator is the capability to create Qt Quick animations using the new timeline editor in Qt Quick Designer.

Qt for Device Creation users will get a major improvement to the Qt Lite configuration tool during 2019. With the new version we are improving the usability of the tool and further extending the configurability of Qt. In addition, we are creating some pre-defined configurations to start from, expected to make it easier to benefit from the tool. One major usability improvement coming with the new version of the Qt Lite configuration tool is capability to directly make the whole configuration with the visual tool, without running separate configure steps.

Tools for Designers: Qt Design Studio and Qt 3D Studio

One of the biggest investments of 2019 will go into the design tooling for both 2D and 3D user interfaces, as well as into further improving the Qt 3D Studio runtime. The long-term goal is to unify the 2D and 3D design tools into one application, of course still having specialized capabilities for 2D and 3D UI. The first steps towards unification are becoming visible during 2019 with multiple shared components, improved interoperability and unified installation of the tools.

Let’s first look into Qt Design Studio, the tool for developing Qt Quick UIs. We published the first release in October 2018. The recently released Qt Design Studio 1.1 provides a lot of polish to the rough edges of the first release, adds merge support for the Photoshop import functionality, as well as brings multiple improvements to the examples and documentation. Also Linux packages are now available in addition to Mac and Windows.

During 2019 we will add many important features to Qt Design Studio, for example support for additional graphics design tools such as Sketch, a new easing curve editor and a new property inspector, both shared with Qt 3D Studio as well. We are also improving multi-monitor support, providing project workspace with dockable windows and finetuning the ergonomics and usability of the application. We aim to make also an open-source release of Qt Design Studio, which is currently only available for commercial license holders.

Qt 3D Studio is getting a major boost in runtime performance with the 2.3 version in March and 2.4 in June 2019. The renewed renderer and animation system as well as support for asset conditioning provide improved performance, significantly reduced CPU load, greatly reduced loading times of the 3D content, as well as lower memory consumption. Throughout 2019, we are making further improvements, allowing complex real-time 3D applications to run well even on mid-tier hardware. For the low-end 3D hardware we recommend leveraging Qt Quick as much as possible and using real-time 3D only for the parts that really need it.

Some of the most interesting new features of Qt 3D Studio coming in 2019 include support for stereoscopic rendering, completely renewed text rendering, distance fields for text, custom vertex shaders and support for precompiled shaders. Qt 3D Studio will also benefit from the new easing curve editor and property inspector, shared with Qt Design Studio. Stereoscopic rendering allows addressing AR/VR use cases easier than before with support for the most common stereoscopic rendering modes. Text rendering of Qt 3D Studio will receive a complete overhaul to be on par with the excellent capabilities Qt Quick offers for text.

With Qt 3D Studio we are also looking into providing an improved integration with content creation tools, such as Autodesk Maya. In addition to tool specific integrations, we aim to improve the already impressive list of supported input formats with new ones such as glTF 2.0 and possibly other new formats during 2019.

Automation, Automotive and other industries

During 2019 we are further developing our offering for safety critical systems. The functional safety certified Qt Safe Renderer will gain the capability to render dynamic text as well as support for large bitmaps. These will allow an even easier creation of complete safety-critical UIs using the Qt Safe Renderer. Furthermore, we are looking into supporting a wider array of hardware as well as possibly running on the simpler real-time operating systems typically available for microcontrollers.

Our offering for Automation and Automotive industries will get some important new features as well. For Automation, we are adding support for the CoAP protocol, first as a technology preview and later as fully supported. In addition, Qt OPCUA becomes fully supported with Qt 5.13 (with some of the new APIs such as QML API still TP) and other automation protocols get a few new features. We also plan to look into Qt OPCUA server implementation, allowing seamless Qt experience also when there is a need to create edge gateway applications.

Qt Automotive Suite will continue to focus on HMI development productivity. This year we aim to improve its capabilities of working with 3rd party service integration and digital assistants, as well as inter-application operation via a new intent API. Through collaboration with Luxoft and KDAB, we will be looking at deep Qt Wayland support with hypervisor composition, and we will work on extending additional out-of-process backends for most automotive use cases For instance separating the UI and vehicle data by leveraging Qt IVI. In addition, we will work on adding useful components such as UI analytics and cursor control. We also continue to address multi-domain use cases by further improving Qt Remote Objects (fully supported with Qt 5.12 LTS) and by improving the graphics sharing functionality.

Work on addressing constantly lower performance (and cheaper price point) hardware continues throughout 2019. Qt is already running on multiple different Cortex-M4 and Cortex-M7 based microcontrollers and widely supported on various low-end ARMv7 and ARMv8 hardware boards. During 2019, we aim to address additional microcontrollers as well as different low-end real-time operating systems for microcontrollers. We are also thinking how to achieve a great developer experience with Qt for microcontrollers. Our long-term goal is to allow development with Qt for microcontrollers to be as easy as any other platform.

Many of the same optimizations and configurability that enables to address the microcontrollers can also be leveraged with the low-end application processors. Qt offers features and functionality not commonly available in the simple frameworks typically used in the low-end devices. With the versatile configuration system, it is possible to choose the needed functionality and leave out the functionality which the application does not require. This allows Qt to fit into a much smaller memory footprint and utilize less system resources than before.

Get Involved

If you want to learn more about upcoming things for Qt, please stay tuned for new blog posts and webinars about the upcoming features, contact our sales teams or join the discussion in the Qt mailing lists and developer forums. We are always delighted to see new contributors in the Qt Project as well as feedback to the pre-releases of Qt via bugreports.

Do you like this? Share it
Share on LinkedInGoogle+Share on FacebookTweet about this on Twitter

Posted in Biz Circuit & Dev Loop, Qt, Roadmap

54 comments

Vincent says:

Are there any plans to develop Qt for AI? What I can come up with are neural network visualization toolkit, interactive neural network simulation environment ……

@Vincent: Some early thinking has been done related on how to best leverage AI solutions with Qt, but nothing yet concrete enough to release during 2019.

ekke ekke says:

sounds great, but I’m missing a Roadmap about “Qt for mobile”

@ekke: I did not write specifically for any particular platform, but rather focused on the cross-platform functionality and tools. We are actively testing on the pre-releases of new mobile OS versions in order to fix issues before users are hit with them. We recently did a major change for Android to switch to clang tools etc. So there is a lot happening also on mobile, like all our supported platforms. This will certainly continue also during 2019.

Ruslan says:

Tuukka, Qt is really great framework.
However new great crossplatform features is losing sense while developer have to learn iOS objective-c and Android java in order to use very basic functions as notifications or picking files as native look.
My opinion is that such basic features are fairly small work capacity features and can be included in coming releases.
Anyway, thank you for a great job.

@Ruslan: I agree that we should aim to avoid frequent need to step outside of the Qt API when developing applications. It is a benefit of Qt that native platform APIs are easily usable – but still we should aim to have it possible to create most applications with the Qt API. This typically is the case, but there are a few items in mobile that we do not currently have a cross-platform API for.

Nikolas says:

But text input on Android is still terrible 🙁
Are there any plans for this?

Jason says:

Not one mention of Mobile.

Sad.

This is where Qt is behind competition like Xamarin, Flutter, etc. It’s been 5 years since official mobile support was announced. I still can’t set display brightness or vibrate without having to go native. Nevermind notifications which would work on desktop too.

Instead we get a list of things like WebAssembly, which has questionable utility to Qt. I was hoping after the developer survey we’d get more love.

-1

@Jason: Many of the items have direct benefits on mobile, even though not being only for mobile. This is the benefit from cross-platform. For example Qt Lottie works across multiple platforms, on iOS, on Android, but also on desktop and embedded. Same is true for the tools and other framework items.

jason says:

I’m aware of that. But you know that’s not what I mean. I understand that mobile non-parity are considered bugs. Fine. But I’ve been clamoring for the past 5 years-ish about having classes that provide cross-platform access to Mobile-specific features, and I’m starting to lose patience, as are a lot of other people. Meanwhile the competition is *increasing* in the mobile space for x-platform kits, and Qt continues to lag further behind.

You (Qt) need to show Mobile some love, or we’re all switching to Flutter, Xamarin, ReactNative. Considering this was 20% of your survey results, that would be a bad business decision to let Mobile atrophy.

Goran Shekerov says:

+1

Christian Feldbacher says:

@Jason: that’s why Felgo (Formerly V-Play) closes this gap Qt has on mobile and provides 200+ APIs on top of Qt.
For example for push notifications, analytics, native controls for iOS, many UI/UX improvements for Android, file handling, notch support, AR and Machine Learning APIs and many more.

For all APIs see: https://felgo.com/qt-app-developers

By the way, the vibration funcionality you mentioned is available here: https://felgo.com/doc/felgo-nativeutils/#vibrate-method

Tham says:

Your best bet is v-play I guess, I don’t know why they put so much efforts into python bindings while pyQt just works but ditch important mobile features either.

20% of Qt users ruse Qt to develop mobile apps even Qt lack so many important features on mobile platforms, yet they prefer to put more resources to replace pyQt rather than put more efforts into mobile platforms, this is weird.

hm says:

I appreciate your great work on the mobile toolchains. But as jason stated, there are fundamental things missing from the mobile implementations which have to be manually implemented using native classes, for instance: reliable document picking and export (iOS NSDocument* classes), reliable (multi-) image/media picking and export, system background downloader (Android, iOS, Win 10/RT), notifications, but also access to system functionality like “keep screen on”. The guys over at vPlay have done some useful things also in the direction of mobile ads and Google Firebase integration but afaik their solution is closed source.

Christian Feldbacher says:

Hi @hm,
V-Play (now called Felgo) provides all the features you mentioned (native mobile document & file handling, multi image picker, background downloading, notifications, ads, Firebase). You can download the free version and check them out, or contact us if you need help with any of them here:
https://felgo.com/contact

Regarding licensing: there is a free personal Felgo license, as well as source code licenses available.

Fabio says:

Any plan to add Qt Quick Designer to Visual Studio tool plugin?

Thomas Hartmann Thomas Hartmann says:

There are no plans in that direction. Development and debugging from Visual Studio is possible, though.
See :https://blog.qt.io/blog/2018/10/08/qml-debugging-visual-studio/

You can of course use Qt Quick Designer or Qt Design Studio in parallel to Visual Studio.
And even Expression Blend from Microsoft is not integrated into Visual Studio.

TTGil says:

With Apple’s deprecation of OpenGL on Mac, shouldn’t it be a pretty high priority for Qt Quick/3D to decouple from GL and have plugin-based renderers? I know some work has been going on with this for a while, but it’s odd to not see it as a high level item for 2019.

TTGil: We are doing research towards this, but do not expect this yet to be released during 2019. OpenGL is not removed from macOS and there are many important macOS applications depending upon OpenGL. If Apple was to remove OpenGL from new macOS versions, we would need to accelerate the work to support Metal for Qt Quick on macOS.

Flavio says:

I honestly don’t get this new focus on Python. One can write a Quick-based app in Javascript if a dynamically typed language is preferred. Also Python is not easily used as shared or static library on mobile devices, so your Qt Python code is less portable than C++ or Javascript. Is there something I am missing? Please enlighten me.

Benjamin says:

There is a big difference between what you can do between Quick’s javascript and Python.

Javascript is very limited as it is designed to be used mainly for Quick GUIs for small scripting tasks.
Using Python one can access all Qt features, including creating widget based software.

In this regard, Python is a replacement for C++. IMHO the main reason for having Python support in Qt is that Python binding have been existing for years and also it opens a new market: Python developers.

ssokolow says:

I don’t know about their interest in it but, for me, QML is an inferior option to Python for desktop uses.

Qt Quick is far inferior to the QWidget API if you want your application to look and feel native on desktop OSes and QML doesn’t match Python’s ability to extend Qt without writing C++.

(Both in its ability to subclass C++ classes to extend Qt and its ability to import libraries completely independent of Qt. For example, if you want to write a UI which sits on top of PyOpenCV to interactively work with algorithms like grabcut which can operate iteratively.)

Tham says:

Because they think user bases of python is growing rapidly, but…..pyQt just work able to use with lots of important python libs. If I want to create a small python scripts with ui, I would use pyQt(In most of the times I only use python for training deep learning models)
If I want to deploy my apps, I will prefer c++, python make things more difficult than c++ when you want to deploy your apps.

Joseph says:

Python is one of the most popular languages in use today; why wouldn’t Digia want to target it?

“One can write a Quick-based app in Javascript if a dynamically typed language is preferred. ”

I won’t get into comparing Javascript, universally criticized second only to PHP for poor design, with Python, universally praised for being eminently readable. But Python is being taught not just in college CS101 classes world-wide, but even down to the grade school level and is the only official language of the Raspberry Pi. Having Python bindings helps introduce Qt to new and young programmers and dramatically expands the potential user base, which is good for everyone.

Ivan says:

It’s not Digia anymore for almost 3 years now.

Jerome Godbout says:

I really welcome the Python implementation, would be even greater if we could use the same python script for mobile application, right now it’s limited to desktop application.

What I wish is an easy way to use my C++ class and module/plugins into Python. That would be the best. We start having quiet some useful C++ implementation class that would be nice to be reused into Python.

We are using the Qml for the GUI that be reused across the platform and language. But the core utilities library cannot be reused and that is a bit sad.

I wish I can develop prototype into Python or do some specific lib development and still used all my previous C++ work with really small to no effort. Maybe I have miss something but that would really help to boost the Qt Python.

I guess people complaining a lot about Qml, haven’t done too much, it’s really cleaner and less messy as the QWidget was. The pitfall is to start doing logic or domain into Qml, keep Qml only for GUI and user interaction and it will shine and making modification is really fast. Now All my C++ is expose to meta with property, which we used for most of our Qml and even old QWidget application and the GUI can be easily interchanged, but the QWidget is way more heavy to maintain in the long run I found so far.

Andrew says:

Has QT marketshare grown over the last 5 years?

@Andrew: Yes. Qt marketshare is growing nicely. This was presented in the Qt World Summit 2018 keynote presentation. Total number of downloads has grown from 3,6M in 2016 to 5,2M in 2018. With the new items such as Qt for Python available we expect the growth to continue.

Rick says:

I am only using Qt in my spare time, not at work, so I do probably not count as a customer. I downloaded the Qt SDK about 5 times by hand in 2018. I guess, this number hasn’t changed over the last 5 years.

In addition to that, my really tiny little Qt-related pet projects received about 150 commits in 2018. Of course I am using some sort of CI because it’s fun, it’s easy to do and it costs me nothing. The CI provider of my choice is powered by Google Computation Engine. Downloading the >1 GB Qt SDK for a single job takes about 5s, installation ~10s. Of course I am building with multiple Qt versions in parallel. Roughly speaking, my contribution is over 300 Qt SDK downloads in 2018.

Would be interesting to know, how many of the 5.2M downloads originate in hot spots like AWS, Azure or GCE.

Tuukka Turunen Tuukka Turunen says:

@Rick: Download numbers are just indicative of growth, not equivalent to number of users. We have many users who get their Qt via the Linux distribution or from internal server (companies, universities). There are also people who pull code from a repository and build themselves. None of these is showing in the download numbers. Some users also download seldom a new version as their project uses an old Qt release.

Rick says:

I never claimed the opposite. In fact it was you who brought #downloads up as an argument for growth.

Christian says:

Are there any plans to integrate Vulkan as a backend for Qt Quick Scene Graph the next year? Or will it take longer (maybe Qt 6)?

@Christian: It is possible to use Vulkan already with the QVulkanWindow: https://doc.qt.io/qt-5/qtgui-hellovulkanwindow-example.html. Longer term we are planning to support Vulkan, Metal etc directly. But not planned for 2019.

Gremwell says:

I don’t give two hoots about the mobile platform, but I would like good old Windows to finally get support for high DPI screens. Qt doesn’t support Windows high dpi because Windows can do fractional scaling (e.g. 125% scaling). Currently Qt just rounds, so 125% is 100% (and things looks small in comparison to other apps) and 150% rounds up to 200% and things look large compared to other apps.

The bug has been present for quite some time (QTBUG-53022), so I hope we can finally bring HighDPI to Windows in 2019

Other than that, super excited about WebAssembly and bringing our app to the web.

Ruslan says:

As quick controls 1 is deprecated, Is it planned to add TreeView component into 5.13?
So far it is one of most voted features.

@Ruslan: Qt Quick Controls 2 TreeView is not planned for Qt 5.13. We are, however, making some small improvements and polish for TableView during 2019.

Michael says:

Updated Treeview in 2019 ?

Dimitrios says:

I like the roadmap. And wish you good luck with it. Leveraging the web in my opinion is an important goal because it enables a whole new level of reach that unfortunatelly has not been available with Qt. Wasm also adds interesting limitations to the table that I think might end improving Qt as a whole. For example in the web size and load times are crucialy important, thus you will have an extra incentive to keep Qt as lean as possible.

Vladimir says:

Glad to hear about Numpy.
Will there be any changes to QPainter?

Steve says:

Good to hear Widgets are going to get some love, it’s been a long time coming. However I’ve never need a circular progress bar and I’ve seen switches implemented in styles. Something I do keep finding a need for and having to implement by less-than-satisfactory means is a dual / range slider. There are enough posts on the internet asking for this (and an attempt in libqxt) that I find it quite frustrating it so rarely gets a mention.

Pavel says:

https://bugreports.qt.io/browse/QTBUG-55905
When?

Philipp says:

https://bitbucket.org/philippun/overhowl/src/master/src/

I’ve implemented a script engine based on QJSEngine which has a debugger based on the internal/private qv4debugger. I dont know if it works properly outside of my project, but maybe it’s of use for you. 😉

Pavel says:

Thanks so much. I use windows +MSVC 64x. I got a few compilation errors. Theoretically, your program can be compiled in this environment?

Pavel says:

thank you! I found my mistakes. the application was compiled.

Eli says:

@Tuukka Turunen nice work! Can we one day expect a package manager like npm/pip/cargo? Qt/C++ is in dire need of a good package manager. And any news on QBS? By the reaction of the crowd no one really liked cmake….

Tham says:

you can try vcpkg, a decent package managers, although only support win, mac and linux

Vincas says:

Check out https://conan.io/

There’s Qt (and more) package available already: https://bintray.com/bincrafters/public-conan/Qt%3Abincrafters

We might get QtCreator support for it: https://bugreports.qt.io/browse/QTCREATORBUG-21785

Paul says:

@eli There’s a community project called qpm. Check out https://www.qpm.io/

Roman Chernenko says:

Do you have any news about Qbs? Do you still want to make it deprecated?

maxwell says:

QtQuick/QuickControls2 are still missing important things for Desktop use (TreeView, polished Tableview). Please make it a priority to fill this gap.

Ionut Dediu says:

Can we use Qt3D for game development? If so are you planning of releasing some nice and simple game demos? At the moment Qt looks very dry, not very exciting … Are you only planning to concentrate on the automotive sector?!?

Tuukka Turunen Tuukka Turunen says:

@Ionut: Qt is used across 70 different industries, which means about everywhere. We have put quite some effort to making demos for automotive, so it is quite visible. But we do a lot more as well – and there are also other demos. Not that much game or entertainment demos, though.

Christian Feldbacher says:

@Ionut: you can find 40+ game demos with full source code here, some of them also 3D: https://felgo.com/games

marcell mars says:

it is understandable that every company should find the way how to be sustainable and dual licensing was one of the strategies for a long time. recently many companies started to blur the ways how the eco system regarding licenses could be checked. i could see some of that wit qt too. that’s unfortunate. will you improve the ways how we can check out what is free software and what is not from the projects announced here? that would be great, very helpful and it would show the respect to the community which supported qt framework in so many way for decades… keep up the great work…

Commenting closed.

Get started today with Qt Download now