Challenge
Business logic lives inside UI classes, so nothing can be tested without clicking.
Agnotic approach
Logic is moved into plain C++ classes with unit tests, and the UI only binds to them.
Qt Development
Qt development services
Your Qt application runs a product, a machine or a lab workflow, and it has to keep working through every Qt release and hardware change. Agnotic Technologies builds new Qt applications and modernizes old ones: desktop tools for Windows, macOS and Linux, and touch interfaces on embedded Linux devices.
Qt Widgets and Qt QuickEmbedded LinuxQt 5 to Qt 6 portsC++ and QML
Trusted by global innovators
The service
What are Qt development services?
Qt development services are the design, build and upkeep of applications written with the Qt framework in C++ and QML, from cross-platform desktop tools to touch screens on embedded Linux devices. Agnotic Technologies builds new Qt applications, ports Qt 5 code to Qt 6 and keeps the build, tests and releases working for your team.
Qt fits products where one C++ codebase must run on several desktop systems, or where a device needs a fast custom interface without a web browser underneath it.
The firmware, drivers and board support under a device interface are covered on our embedded software development page. The C++ libraries behind the interface are covered on our C++ development page.
Decision table
Qt Widgets or Qt Quick: which fits your interface?
The first decision on any Qt project. We make it from the device, the input method and the team that will maintain the code, not from what looks newer.
| Criterion | Qt Widgets | Qt Quick (QML) |
|---|---|---|
| Best suited to | Dense desktop tools: forms, tables, trees, docked panels and menus | Touch screens, animated or brand-styled interfaces, device front panels |
| Input | Mouse and keyboard first | Touch and gestures first, mouse and keyboard supported |
| How the interface is written | C++ classes, often laid out in Qt Designer .ui files | Declarative QML with JavaScript bindings, logic exposed from C++ |
| Rendering | Painted widgets, works without a GPU | Scene graph drawn through the GPU, so the board's graphics support matters |
| Look and feel | Close to the native desktop style out of the box | Custom styling is the norm, through Qt Quick Controls styles |
| Team skills | C++ developers | C++ for the back end, QML for the interface, often a designer in the loop |
The two can share one application: a Qt Widgets main window can host a Qt Quick view through QQuickWidget, which lets a team move screen by screen instead of rewriting everything at once.
Embedded Linux
Which display backend should an embedded Qt device use?
On an embedded Linux board, Qt draws through a platform plugin. The choice depends on the GPU, the number of applications on screen and how the image is built.
| Code | Name | Typical use |
|---|---|---|
| EGLFS | Single full-screen app with a GPU | One Qt Quick application drawing straight to the display through EGL and OpenGL ES, with no windowing system. The usual choice for a device front panel. |
| LinuxFB | Boards without a GPU | Writes to the Linux framebuffer with software rendering. Suits simple Qt Widgets screens on low-cost hardware. |
| VkKhrDisplay | Vulkan straight to the display | Renders through Vulkan without a windowing system, on boards whose drivers support it. |
| Wayland | Several apps or processes on screen | Runs as a client of a Wayland compositor, so several applications can share the display. Needs a compositor in the image. |
What do we build with Qt?
Qt work we design, build and support for product and engineering teams.
Cross-platform desktop applications
One C++ codebase for Windows, macOS and Linux, with installers, updates and native file dialogs.
Touch interfaces for devices
Qt Quick front panels for medical, industrial and consumer devices, tested on the target board from the first sprint.
Instrument and lab software
Desktop control and analysis tools that talk to instruments over USB, serial or Ethernet and plot data live.
Qt 5 to Qt 6 ports
Staged ports that keep the application shippable at every step, with the build moved to CMake.
Widgets to QML migrations
Screen by screen moves from Qt Widgets to Qt Quick where touch or a new design needs it.
Build, test and release pipeline
CMake builds, unit tests with Qt Test, UI tests and signed release packages produced in CI.
Porting
How do we port a Qt 5 application to Qt 6?
A port is a series of small, tested steps. The application stays releasable throughout.
Get to Qt 5.15 first
The application is moved to the last Qt 5 release, where the gap to Qt 6 is smallest, and released from there.
Remove deprecated API use
We build with QT_DISABLE_DEPRECATED_BEFORE set so every call to an API deprecated in Qt 5.15 becomes a compile error to fix.
Move the build to CMake
qmake projects are converted to CMake, the build system Qt 6 itself uses, with presets for each platform.
Bridge removed classes
Where code still needs Qt 5 classes removed in Qt 6, the Qt 5 Core Compat module carries it over while those parts are rewritten.
Port and compare
Module by module, the Qt 6 build is checked against the Qt 5 build with automated tests and screenshot comparisons of key screens.
Retire the bridge
Once the compat classes are replaced, the module is dropped and Qt 5 builds are switched off.
Failure points
Where do Qt projects go wrong?
The problems we find most often when we take over a Qt codebase, and what we do about them.
Challenge
Long operations run on the UI thread and the screen freezes.
Agnotic approach
Device I/O, file work and calculations move to worker threads, with results passed back through signals.
Challenge
The interface is smooth on a developer laptop and slow on the device.
Agnotic approach
We run builds on the target board from the start and profile rendering there, not on a desktop.
Challenge
QML binding loops and heavy JavaScript slow the interface down.
Agnotic approach
Bindings are kept simple, heavy logic moves to C++, and the QML profiler runs before each release.
Challenge
Text and icons look wrong on high-DPI screens or in other languages.
Agnotic approach
Layouts use scalable units and vector icons, and translated builds are tested with the longest strings.
Challenge
The Qt license is chosen after the product ships.
Agnotic approach
Licensing is settled with your team and counsel during scoping, before modules and linking are fixed.
Licensing
Commercial or open source Qt: what changes for your product?
Which license you use is your decision, made with your legal team. These are the engineering choices each one shapes.
01
Commercial license
Example: A proprietary product where you do not want to share source code or cannot meet LGPL terms
Approach: We build under your license. Static linking and closed modifications to Qt become options, subject to your agreement with The Qt Company.
02
GNU LGPL version 3
Example: An application that can meet the LGPL, for example by linking Qt dynamically
Approach: We keep Qt as replaceable shared libraries, ship the license texts and record any changes to Qt itself so the obligations can be met.
03
Locked-down devices
Example: An embedded product where users cannot replace software
Approach: LGPL version 3 has terms on installation information for consumer products. Your counsel decides how they apply before the image design is fixed.
04
Module by module
Example: Add-on modules and third-party code shipped inside Qt
Approach: We list every Qt module the product uses and check each one's license, since not all modules are offered under the same terms.
Who it is for
Who hires us for Qt work?
Teams with a Qt product to build, rescue or move to a new Qt version.
Device makers
Companies that need a touch front panel on an embedded Linux board, built alongside the firmware.
Lab and instrument companies
Makers of analyzers and test equipment whose desktop software controls the instrument and shows results.
Industrial equipment makers
Machine builders who need operator screens that run for years on fixed hardware.
Desktop software vendors
Teams with a long-lived Qt 5 application that must move to Qt 6 without stopping releases.
Qt development for startups
Founders building a first device or desktop product who need the interface choice and build set up right from the start.
Scope and cost
What drives the cost of Qt development?
We do not publish prices. These are the factors we size a Qt project from on the scoping call.
Target platforms
Which desktop systems and boards the application must run on, and how many of each need testing.
Interface technology
Qt Widgets, Qt Quick or both, and how much custom design and animation the screens need.
Hardware access
Instruments, serial and USB devices, cameras or sensors the application talks to.
Existing code
Size and age of the codebase, the Qt version it is on and how much test coverage exists.
Target testing
Access to the real board or instrument, and how much testing must happen on it.
Regulated products
Extra documentation and test records when the software is part of a medical or safety-related device.
Engagement
How does a Qt engagement run?
From the first look at your code or hardware to releases your team can maintain.
1.
Scoping call and review
We review your code, Qt version, target hardware and licensing, and agree what the first release covers.
Scope2.
Prototype on target
Key screens run on the real board or platform early, so performance surprises appear in week one, not at launch.
Prove3.
Fixed-scope first release
We build the agreed screens and logic with tests and a CI build that produces installable packages.
Build4.
Scale and support
We add features, ports and platforms, or hand the code and build over to your team.
SupportStandards
Qt documentation we build to
The Qt guidance behind interface choices, embedded builds and ports.
Qt WidgetsQt QuickEmbedded LinuxQt 6 portingLGPLv3
Facts and sources
Facts behind Qt development
Qt's own documentation on interface technologies, licensing, embedded Linux and porting, each linked to the source.
Qt names Qt Quick and Qt Widgets as its main user interface technologies: Qt Quick interfaces are fluid, dynamic and best on touch interfaces, while Qt Widgets are for creating complex desktop applications.
Source: User Interfaces, Qt 6 documentation (The Qt Company)Qt is offered under commercial licenses, for proprietary software where you do not want to share source code or cannot meet the GNU LGPL version 3, and under the GNU LGPL version 3 for applications that can comply with its terms.
Source: Qt Licensing, Qt 6 documentation (The Qt Company)On embedded Linux, Qt can run through the EGLFS, VkKhrDisplay, LinuxFB or Wayland platform plugins. Wayland needs a compositor, while the others run without a windowing system and give the Qt application full control of rendering.
Source: Qt for Embedded Linux, Qt 6 documentation (The Qt Company)Qt advises updating a Qt 5 application to Qt 5.15 before upgrading to Qt 6, because Qt 5.15 has the fewest changes from Qt 6, and APIs marked deprecated or obsolete in Qt 5.15 may have been removed in Qt 6.
Source: Porting to Qt 6, Qt 6 documentation (The Qt Company)
Frequently Asked Questions
We do not publish a price. Cost follows the target platforms, whether the interface uses Qt Widgets or Qt Quick, the hardware the application talks to, the state of any existing code and how much testing must run on the device. You get a written proposal after the scoping call.
It depends on how much deprecated API the code uses, which Qt modules it depends on and how much test coverage exists. We review the code first and then agree a staged plan, with the application releasable after each stage.
That is your decision, made with your legal team. A commercial license suits products that cannot meet LGPL terms, such as statically linked or locked-down devices. Many desktop applications can use Qt under the LGPL version 3. We build the application to fit whichever you choose.
Qt suits devices that need fast start-up, smooth touch input and direct hardware access on modest boards. A web stack suits products whose interface must also run in a browser. We compare both against your board and team on the scoping call.
Yes. A Qt Widgets window can host a Qt Quick view through QQuickWidget, and a Qt Quick application can call C++ logic shared with the widget code. That makes it possible to move to QML one screen at a time.
Yes. We start with a code and build review, get the application building and testable in CI, then fix the highest risk problems first, such as UI thread blocking or untested logic, before adding features.
Yes. A common first release is the core screens running on the target hardware with the build, tests and installer in place. Later releases add screens, platforms and integrations.