Announcing the Qt Automotive Suite
blog.qt.io
blog.qt.io
What I would like is something like electron that can run on a frame buffer. What's the current state of the art for a html5 based embedded interface?
If you intend to launch a closed-source* product at some future date and pay the per-unit licensing fees, the developer needs a seat license from day one.
(* closed-source or code that statically links in the Qt libraries)
* Not accusing you of course; I'm totally convinced that it can come from a misguided sales rep trying to close a deal as early as possible.
It's always been explained to me by the sales people that "you cannot switch licensing models mid-stream". So if you're planning to go commercial, you start commercial.
It's not really about closing the deal as much as making sure the Trolltech developers were paid during the time you needed their support.
The OSS license doesn't grant you any support from Trolltech, does it?
I would totally understand the response eventually turning into "yeah, we'll fix your bug, but put your money where your mouth is", which is where they are today.
As for Qt for Device Creation, I looked through that and didn't see why you'd need a license there, unless they're selling optional components or plug-ins which are not LGPL licensed (which appears to be the case with things like "Qt Quick 2D Renderer" and "Qt Virtual Keyboard").
I even tried out the questionnaire at www.qt.io/download: if you select "Commercial deployment" for development and then say that you're doing dynamic linking, don't have any concerns about reverse-engineering, and can comply with the LGPL, it recommends you use the open-source LGPL'ed version.
Qt for Device Creation needs a license, that one is not available as LGPL. Of course you can use the open source Qt yourself for that, but then you'll be facing a lot of platform work to get Qt running on your device before even starting with the stuff that you actually want to build.
You're right, it does sound a bit nasty. No, I haven't read the license myself. It's been brought up multiple times on official Qt blog comments and mailing lists, though.
Edit: checked it now, and it's clearly written at https://www.qt.io/faq/, "Developing with a Commercial License":
> Q: If I have started development of a project using the open source version (LGPL), can I later purchase a commercial version of Qt and move my code under that license?
> A: This is not permitted without written consent from The Qt Company. If you have already started the development with an open-source version of Qt, please contact The Qt Company to resolve the issue.
OSS was a completely different animal back when this thing started. And it was forward thinking to avoid the whole problem with people demanding free support and bugfixes for open-source code.
As for the reasoning, a customer developing their product for years in-house and switching to commercial just before releasing would definitely place Qt financing in a shaky ground when compared to traditional commercial frameworks.
If your project decides to go commercial the initial license term will include a cost of conversion based on the quantity of code already written.
It would be interesting if they expressed that rate as something like:
A gz -1 compressed tarball of the affected source code will be created, the size (in bytes) multiplied by X is the maximum fee we would charge for retroactive licensing.
I choose the wording 'maximum' there as it still allows them to offer better deals under other circumstances.
Qt is not an end-user, boxed product. This may shock you, but B2B software doesn't always have a public, standard price list.
My rule of thumb for pricing is that if someplace /makes you ask/ they aren't going to sell at a price you'd find worthwhile.
The notion of charging by byte, as if software were content farming, shows that you are obviously not a professional.
*NOTE: If Licensee, or another third party, has, at any time, developed or distributed all (or any portions of) the Application(s) using an open source version of Qt licensed under the terms of the GNU Lesser General Public License, version 2.1 or later (“LGPL”) or the GNU General Public License version 2.0 or later (“GPL”), Licensee may contact The Qt Company via email to address sales@qt.io to ask for the necessary permission to combine such development work with the Licensed Software. The Qt Company shall evaluate Licensee´s request, and respond to the request with estimated license costs and other applicable terms and details relating to the permission for the Licensee, depending on the actual situation in question. Copies of the licenses referred to above are located at http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html, http://www.gnu.org/licenses/lgpl-3.0.html, http://www.fsf.org/licensing/licenses/info/GPLv2.html, and http://www.gnu.org/copyleft/gpl-3.0.html.
So really the questionable term isn't an additional term on the LGPL, it is on the commercial license.
I think this is mostly meant to avoid having a team of 50 develop an internal version based on LGPL, and then a team of 1 maintain the commercial version, paying a single developer seat.
Note that you can still do a throw away prototype without problems. Some say you should in any case!
Personally, I'm keeping my eye open on libui (https://github.com/andlabs/libui/) as it is already possible to do some basic things with it. However, it is pretty much in alpha state and I'm slowly writing the Python bindings for it at https://github.com/joaoventura/pylibui/. The thing that I like in the libui is that it is a thin wrapper around platform specific frameworks. Therefore, the library is very small (some 340 KB) and it's as native as the underlying platform calls are..
Regarding Electron, I am writing an application on it, but it is too god damn heavy in terms of memory, disk space and boot time, and web front-end development is absolute chaos these days. Although I'm currently writing my app on it, it is mostly an MVP as I want to make pylibui/libui usable enough to switch to a pure desktop cross-platform library asap..
Try Sciter HTML/CSS engine then (http://sciter.com). It is a monolitic DLL (4-8 Mb) without external dependencies. Works on Win/Lin/OSX and even on Raspberry Pi 2 - http://sciter.com/sciter-on-raspberry-pi-2/
However it lacks in some areas, such as the scrolling which is quite bad, and it does not render the SVG files that I'd need it to render (tiny SVG spec, but lots of defs and rotations). I'm still going to look better into it since I can use Cairo and CairoSVG to convert my SVGs to PNGs, but I still do not know how well it renders some css rules, fonts, etc..
I mean, if you don't need to modify the Qt-library, you don't need commercial license. You just need to provide link to the Qt-sources.
Which clause of the GPL/LGPL makes you say that, or is there prior judgement that resulted in making such a demand?
d) Do one of the following:
0) Convey the Minimal Corresponding Source under the terms of this License, and the Corresponding Application Code in a form suitable for, and under terms that permit, the user to recombine or relink the Application with a modified version of the Linked Version to produce a modified Combined Work, in the manner specified by section 6 of the GNU GPL for conveying Corresponding Source.
1) Use a suitable shared library mechanism for linking with the Library. A suitable mechanism is one that (a) uses at run time a copy of the Library already present on the user's computer system, and (b) will operate properly with a modified version of the Library that is interface-compatible with the Linked Version.
Sounds like all you have to do is prove your build on your dev machine works with newer versions. Up to the user to update the library on the target machine!
> With LGPLv3 it is explicitly stated that the user also needs to be able to run the re-linked binary, and that sufficient installation information must be provided.
0) leaves room for interpretation: when it says "to recombine or relink the Application with a modified version of the Linked Version to produce a modified Combined Work", should we read this as "the very same Version, modified to accommodate some needs while keeping API compatibility in mind" or a much-broader "any later Version, maybe even upstream, that may have received drastic API changes" ?
1) has boundaries: you are supposed to be able to "operate properly with a modified version of the Library __that is interface-compatible__ with the Linked Version". This notion of interface-compatibility seems here to prevent an attacker from saying to a commercial developer: "Here's Qt 42.0, now you will update your code for free for me so that it runs on it". Doesn't it?
More broadly, do you know of any lawsuit where these points were used to successfully prove non-GPL compliance and require more work from a commercial user?
EDIT I'm asking this (and my initial question) because it seems such a clause w/should have absolutely deterred commercial developers from using GPL libraries at all. Not starting a flamewar, I know MIT/BSD/Apache libs are generally more reassuring and popular in commercial software, but GPL code keeps being used by commercial software under the basic "We'll mention usage of the GPL lib in the docs, and will either leave the lib untouched or publish our modifications" promise. This condition as you interpret it seems much more chilling, I'm surprised to hear about it and would like to understand how severely it's enforced.
With LGPL libraries I find a lot of developers aren't aware of the relinking requirement, but it does get enforced. That's why you won't find LGPL libraries being used in the iOS App Store and why you need to buy a commercial license for Qt for mobile.
Of course none of this applies to server apps since they aren't distributed to users. You can use all the GPL code you want.
Thanks for contradicting. I almost swore nonsense, but I'm so unsure about everything when it comes to licensing that I thought I'd read about it first, and you're right. I'm flabbergasted; never understood this, and never met anyone confident enough about their understanding of GPL to contradict my (wrong) understanding.
But then, does this mean anyone can ask for the source of closed-source software that use GPL code, like the ones below? (I just dug two random examples).
- AutoDesk software. Uses GPL components at http://www.autodesk.com/company/legal-notices-trademarks/ope... -- EDIT: alright these are all _L_GPL libs, which means just distributing the (potentially modified) lib sources is okay as long as you don't link statically. Right?
- HipChat Enterprise. Server-side, but distributed, to be run by enterprises on their own servers. Uses GPL components at http://sources.hipchat.com/ -- EDIT: in this case, all the GPL components seem to be basic GNU utilities, used by calling binaries rather than being coupled to the commercial software by a linking / shared object mechanism. Right?
If their software is a derivative work of someone else's code then they can't distribute their software without a license from the copyright holder of that code. In the case of the GPL, that licenses them only to distribute their code under the GPL. If they are distributing their software other than under the GPL, then that is copyright infringement (in the same way as if they had made a derived work of some non-GPL code and distributed that), they lose their license, and any holder of a copyright on the code that their software was a derivative work of could sue them for copyright infringement. (In theory they sue for damages; in practice the copyright holder of GPLed code they made a derivative of will usually settle for compliance and an agreement to have their future releases audited).
What constitutes a derivative work is a question for the courts. It's generally accepted that any program that uses a library is a derivative work of that library, and a program that invokes another program at arms length or via a standard interface is probably not a derivative work of that program. The exact boundary is unclear; there's a case to be made that a program that is tightly coupled to another program and invokes it via piped commands might still be a derivative work even though it's not shared objects.
The LGPL is an entirely different license from the GPL.
The incentives for me to comply with those terms are nonexistent, which is never a sign of a good contract.
How dare Qt demand that others pay them before developing a commercial product using their code?
I have no problem paying Qt. I'm just unwilling to do it until I know its the direction I want to go. The current Qt licensing structure adds friction to my making that decision.
Most commercial vendors won't give you their entire product for free until your own product is half-built. Qt is different; they offer an entire free product. You want to have your cake and eat it too.
In any event the only issue is the weird quirk of the Qt commercial license preventing you from switching to commercial from LGPL. Which I and apparently a few other people in the thread really didn't get at first.
Their standard Qt for Application Development license gives you a free 30 day evaluation period. Also, I don't think any of this encompasses simply examining the free product without use in product development, e.g., reading the APIs, documentation, and source code. That's a lot of freebies, that you don't necessarily get with other commercial products.
> In any event the only issue is the weird quirk of the Qt commercial license preventing you from switching to commercial from LGPL. Which I and apparently a few other people in the thread really didn't get at first.
There's no weird quirk. As they state, "If you have already started the development with an open-source version of Qt, please contact The Qt Company to resolve the issue." If you have money, they will take your money. But if you want to develop a commercial product and use Qt up front then you have to budget for it. If you can't afford it then use something else. No one is holding a gun to your head forcing you to develop a proprietary product with Qt.
Does the company that you work for (or yours if you're a founder) take the same "take it or leave it" attitude towards potential customers?
So does Qt. So much so in fact, they even offer an entire free product; evaluate it all you want. Just don't use it to build a commercial product while paying zero dollars and then come back when it's half-built and expect to dictate pricing terms after the fact.
> Does the company that you work for (or yours if you're a founder) take the same "take it or leave it" attitude towards potential customers?
I'm not going to talk about my work here. I'm writing on my anonymous behalf only. I've worked at places that were more or less liberal with evaluations and more or less tolerant of tiny accounts. I have never worked somewhere that salespeople loved customers who wasted their time asking for freebies and handouts with illusory promises of future money that never seems to materialize.
No, they don't. Not in any meaningful sense. They're offering to let you evaluate a bed, so long as your evaluation doesn't include sleeping on it.
> expect to dictate pricing terms after the fact
Excuse me, but who here has said a single thing about the customer dictating terms? Not a single person.
> I'm not going to talk about my work here.
The question was rhetorical, thanks.
> who wasted their time asking for freebies and handouts
No one is asking for either a hand-out or freebie. Potential Customers are asking to evaluate a product before paying for licenses THAT THEY MIGHT NOT USE. That is not un-reasonable.
It feels like the Qt Company is pushing C++ down the stack, with QML getting the main focus as application development language.
You don't want a Word-like app in your car dashboard, but a iOS-like app.
Same applies to Android, UWP and even Tizen with their respective native languages.
So it is a conscious decision not to provide C++ APIs besides the old QtWidget and make developers use QML and its compiler instead, as far as I understand it.
I've used Qt myself for desktop, mobile, and embedded development. For mobile and embedded I would not use widgets, and probably not even for desktop. I understand why the widgets still has staunch fanbase, but they do not belong everywhere.