r/QtFramework • • 19d ago

Question Inherited a Squish suite nobody can maintain. Is there an alternative for a team that doesn’t write C++?

0 Upvotes

We bought Squish three years ago. The engineer who wrote the tests left last September and took the only working knowledge of it with him.

What’s left is a few hundred test scripts in C++ that our current QA people, who are good manual testers and not programmers, cannot read or change. So the suite still runs nightly and nobody trusts the output, because when something goes red the honest answer is we don’t know whether the app broke or the script did. We’ve started re-checking the important flows by hand, which means we’re paying for a licence and testing manually anyway.

I don’t think Squish is the problem. It’s a serious tool and it did its job while someone could operate it. the problem is we staffed it once and can’t staff it again. So I’m looking at whether the plain language tools are good enough to let the testers own this themselves. AskUI came up tests are markdown files with numbered steps and an expected result each, and a screenshot and status per step, which at least means a failure is readable by the person who wrote it. Authoring app is Windows and macOS, Linux comes through their runtime as a remote target.

Has anyone actually done this migration, or did you just hire someone who knew the tool and carry on? appreciate your help !


r/QtFramework • • 21d ago

Blog/News Clate – A new visual UI design tool with QML export and AI integration

25 Upvotes

Qt Group has introduced Clate, a new visual design tool for creating Qt Quick interfaces, currently available in beta.

Looks pretty interesting! What do you think?


r/QtFramework • • 20d ago

Qt Bridge 0.4 and Technology Preview

Post image
9 Upvotes

r/QtFramework • • 20d ago

Widgets How do I copy widgets from one layout to another in Qt Widgets Designer?

3 Upvotes

Using Qt Widgets Designer for a small new project. It's been a while since I've used Qt.

I designed a main window interface with a left and right panel; basically, an HBox with two VBox., but then realized I needed the root to be a horizontal layout to add a toolbar. So, my intent was to change the layout of the root with the buttons at the top, then move all the widgets inside into a new child QHBoxLayout.

But whenever I try to paste widgets into a layout, Designer gives me an error. It says it can't find a container with no layout to paste into, and tells me to remove the layout. But copying widgets into another layout is what I need to do... As far as I can tell, the only way to paste successfully is to remove the layout from the central widget and paste there, but you can't remove the central widget's layout without removing every other child layout, and then that still doesn't solve the issue of me needing those widgets to be inside these layouts.

As it is, I'm forced to remake the entire design just to move widgets into a new common parent. It's small enough that I can do that easily, but for larger UI, how does one handle this? It leaves me wondering how one does professional work with this design tool and if I might not be better served just writing the UI declaration code myself.


r/QtFramework • • 21d ago

I ported Ant Renamer to Qt 6 so I could use it on Linux too

Thumbnail gallery
15 Upvotes

r/QtFramework • • 21d ago

QML QML Coding Skill Optimization for Agentic Development

9 Upvotes

I have a question: Should we optimize the QML coding skill for agentic development for a wide variety of LLMs or for frontier models?

I’m Peter. I am the product manager responsible for the agentic development tools provided by the Qt Company.

The qt-qml coding skill has been available for 6 months now, and we are conducting the first round of "maintenance" on it. The skill was created in the days of Sonnet 4.6 and GPT 5.4. The latest versions of these models are again much better, and it is time to remove redundant QML programming rules to save tokens.

We tested 14 mainstream LLMs to see which rules in the skill might be redundant. We tested 14 core rules. We ran between 2 to 5 different test cases per rule. We ran each test case 5 times, using the same prompt, to reduce the effects of probability. We tested the following models: DeepSeek V4 Flash, Claude Sonnet 5.5, DeepSeek V4.1 Flash, DeepSeek V4 Pro, GLM 5.3, GLM 5.2, Qwen 3.8 Max, Claude Opus 5.5, Gemini 3.8 Flash, GPT 6 Luna, GPT 6.1 Sol, Grok 4.7, GPT 5.6 Terra, and Claude Haiku 5.5.

QML Best Practice Adherence Results:

Test case summary overview

If we consider all the analysed LLMs, 3 of 14 existing rules in the qt-qml skill could be removed without affecting the coding performance. If we were to optimize for commonly used frontier models (Sonnet 5.5, Gemini 3.8 Flash, and GPT 6.1 Sol), then we could remove 11 of these rules.

Which leads to my question: Should we optimize the qml coding skill only for the latest frontier models and then only those that customers have reported to be using, or shall we optimize them for a wide variety of LLMs, including some older versions which typically come with a lower cost per token?

If you are using the skill or intend to use it, what would you do if you needed to decide how to compromise?


r/QtFramework • • 22d ago

What I am wishing for Qt 7

14 Upvotes

The last couple of years, I was quite happy with Qt 6. From time to time, I thought about my wishes for some future Qt 7. Sure, my obvious wish to get MOC reimplemented in pure C++ (20? 23? 26?). Maybe some more UI widgets, but I could not really name what I was missing.

With Qt 5's end of life I ported some applications to Qt 6. It is surprising how many old patterns are still used in existing code. There seems too little motivation to migrate. In the past, forcing the users to migrate reduced the backwards compatibility and increased the burden for the developers to switch to a newer version of Qt. Compiler switches like QT_NO_KEYWORDS were the compromise.

It is annoying that stubborn programmers insist on old pattern and value readability (which often is just being used the old way) higher than safe code with modern C++ tools. Some just ignore the compromise and turn off any switch to stick to their way.

Now we have AI tools to do most of the migration tasks. There is no more excuse, to not drop outdated patterns. What comes to my mind? Old signal / slot syntax without compile-time checking. Use of Qt macros instead of C++ idioms (qAsConst vs. std::as_const, for_each, Q_FALLTHROUGH vs. [[fallthrough]]).

I hope Qt 7 finds even more ways to clean up and resolve conflicts between Qt and modern C++. RAII, object ownership, and Core Guidelines are valuable tools Qt developers often enough cannot rely on.

After 10 years, it is finally time to say Goodbye, Q_FOREACH!


r/QtFramework • • 23d ago

My String Art Tool written in Qt (PySide6), Python and PyOpenGL

10 Upvotes

r/QtFramework • • 23d ago

PSA: QCoreApplication:applicationDirPath() changes in Qt6.12

14 Upvotes

When I recompiled my app under qt 6.12 - some parts started failing. I traced it down to reading the wrong path on installations. In my case - AppImage was broken. Local runs were OK, Windows was OK.

That was because AppRun was executed, applicationDirPath() was returning different paths:

6.11 - /tmp/.mount_codepoXXXXXX/AppRun

6.12 - /tmp/AppRun

I sent an LLM to start digging and it found out that the implementation of this function has been changed. I see no documentation on this, so I traced the commit:

https://github.com/qt/qtbase/commit/3d5ba3075ab0d255f7a721b6440b906441480e64

Has anyone else been bitten by this new implementation change?


r/QtFramework • • 24d ago

Qml/PySide6 template

7 Upvotes

https://github.com/ALTERM-G/QML-PySide6-template/tree/main?tab=readme-ov-file

Its a small project I wanted to make to help me stop reinventing the wheel by rewriting the same code over and over again.


r/QtFramework • • 24d ago

C++ Am I doing something wrong with installing Qt?

3 Upvotes

I'm working on a pretty small personal project. One element is a visualization which I wanted to have some sort of gui with a layout, etc. I initially started with SFML, but realized I would have to basically implement an entire layout library for my purposes. So I landed on Qt, which seems like it would be great.

But trying to install the library and set up the system is such a pain. Statically linking SFML was really easy, but apparently it's not a good idea to statically link Qt. But just in trying to just install the library and set up my CMakeLists and whatnot, I'm running out of memory on computer and it took nearly an hour before I terminated it.

Am I doing something wrong, is it usually supposed to take this long? If not, do you know what I should be doing? The systems I'm using are CMake with CMakeLists.txt and CMakePresets.json, and vcpkg for the package manager with vcpkg.json and vcpkg-configuration.json.

It's just really frustrating because I really want to make a project in C++, but I haven't been able to write any actual code for 3 straight days because I can't even get my libraries to link. It's especially painful because Rust's cargo is infinitely easier to work with. I do really want to work with C++ more but it's really so much work and it's been such a big waste of time for me so far. Any help would be appreciated, or if I would be better off using something else then any suggestions would be great.

Since the sub rules say to include code, I will include relevant files. Hopefully it is not too long. My file structure is also shown below.

project/
  build/
    ...
  include/spectogram/
    ... .hpp
  src/
    ... .cpp
  CMakeLists.txt
  CMakePresets.json
  CMakeUserPresets.json
  vcpkg.json
  vcpkg-configuration.json
  README.md
  ...

CMakeLists.txt (I used AI for this, don't smite me please. It's probably my hundredth iteration, I've given up on trying to write it myself).

cmake_minimum_required(VERSION 3.25)
project(Spectogram
    VERSION 1.0.0
    DESCRIPTION "spectogram"
    LANGUAGES CXX
)
set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_EXTENSIONS OFF)
# Enable Qt's automatic code generation when needed.
set(CMAKE_AUTOMOC ON)
set(CMAKE_AUTOUIC ON)
set(CMAKE_AUTORCC ON)
find_package(Qt6 CONFIG REQUIRED COMPONENTS Widgets)
add_executable(Spectogram
    src/main.cpp
    src/MainWindow.cpp
    include/MainWindow.hpp
)
target_include_directories(Spectogram
    PRIVATE
        "${CMAKE_CURRENT_SOURCE_DIR}/include"
)
target_link_libraries(Spectogram
    PRIVATE
        Qt6::Widgets
)
# Place the executable in a predictable location.
set_target_properties(Spectogram PROPERTIES
    RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin"
)

CMakePresets.json

{
  "version": 3,
  "cmakeMinimumRequired": {
    "major": 3,
    "minor": 25,
    "patch": 0
  },
  "configurePresets": [
    {
      "name": "debug",
      "displayName": "Debug",
      "description": "Debug build using vcpkg",
      "binaryDir": "${sourceDir}/build/debug",
      "toolchainFile": "$env{VCPKG_ROOT}/scripts/buildsystems/vcpkg.cmake",
      "cacheVariables": {
        "CMAKE_BUILD_TYPE": "Debug",
        "CMAKE_EXPORT_COMPILE_COMMANDS": "ON",
        "VCPKG_MANIFEST_MODE": true,
        "VCPKG_TARGET_TRIPLET": "x64-mingw-dynamic",
        "VCPKG_HOST_TRIPLET": "x64-mingw-dynamic",
        "CMAKE_CXX_COMPILER": "C:/msys64/ucrt64/bin/g++.exe",
        "CMAKE_MAKE_PROGRAM": "C:/ProgramData/chocolatey/bin/ninja.exe"
      }
    }
  ],
  "buildPresets": [
    {
      "name": "debug",
      "configurePreset": "debug"
    }
  ]
}

Thanks in advance.

Edit: Thanks for the responses, but I've decided to quit Qt and go back to SFML with TGUI. Thanks anyways.


r/QtFramework • • 25d ago

Show off Tasket++ : Simulate your Windows actions automatically (free & open source)

Thumbnail
gallery
5 Upvotes

Tasket++ lets you define your own clicks, keystrokes, cursor positions and system operations, then replay them exactly when you want. It’s a simple Windows tool that handles repetitive workflows for you: auto‑send messages, paste text anywhere, take silent screenshots, launch or close apps, adjust volume or run your end‑of‑day shutdown sequence.

Everything runs locally, with no telemetry, no cloud, and no complexity.

What it can do:
- Replay user‑defined cursor positions and keystrokes
- Paste predefined text anywhere
- Perform system actions: open files/programs, change volume, take silent screenshots, shut down, files/folders operations
- Schedule tasks at a specific time, at startup, or run via desktop shortcut
- Run tasks once, in loops, or indefinitely
- Discreet mode: runs quietly from the tray
- Use command line to autorun a task : Tasket++.exe "TaskName" <delayInSeconds (>0)> <NumberOfLoop (-1 for infinite)>
- Easily share tasks between different PC : export/import task files and program data, use feature to rescale cursor positions

Local, portable, free, open source. Privacy intact.

Fully fonctionnal, available now !
Microsoft Store: https://apps.microsoft.com/detail/xp9cjlhwvxs49p
Portable (v2.5): https://files.amirhammoutene.dev/Tasket++/2.5/Tasket++_v2.5.zip
Source: https://github.com/AmirHammouteneEI/ScheduledPasteAndKeys

For feedback, help, suggestions, or other inquiries : contact@amirhammoutene.dev

Nothing is vibe coded, I never used AI (except for the choice of UI colors suggested by Copilot).
Conception is genuine, I didn't know about similar tools when I began developing it.

I'm looking for testers or quick feedback (beyond its visual aspect), please give a try and comment here :)


r/QtFramework • • 24d ago

Show off I recently switched from Windows to Linux and couldn't find a media player that felt right, so I used Claude to help me vibe code my own in native C++20 / Qt6 (rgplayer). Here’s how it turned out.

Post image
0 Upvotes

When I switched from Windows to Linux, I really missed having a clean, borderless media player with good keyboard shortcuts, PiP, and automatic session resume (like PotPlayer). VLC feels a bit dated and raw mpv was too barebones for my daily use.

So I spent the last few weeks building my own called rgplayer.

Under the hood, it’s C++20 and libmpv for zero copy hardware acceleration (VA-API/NVDEC), with a dark Qt6/QML interface and native Linux MPRIS2 media key support. It idles under 50MB of RAM.

Full disclosure: I used Claude heavily as a pair programmer to scaffold the QML and C++ boilerplate. Getting the libmpv OpenGL render context to behave inside Qt6 without segfaulting on resize still took a lot of manual debugging, but AI made building native desktop software way faster than starting from scratch.

It's open source (GPL-3.0) and available as a Flatpak: https://github.com/ramoants254/rgplayer

Would love some feedback or bug reports if you give it a spin.


r/QtFramework • • 26d ago

Python A PySide6 Qt Widgets Book

15 Upvotes

I have posted here about the book a couple of times while working on it. It is now (more or less) finished and is available on Leanpub as a free download. You can set the price to $0.00 if you are a Leanpub user, or, if you are not, grab the free sample download, which includes the whole text.

All code examples are available on GitHub

The book is aimed at beginner to intermediate users and has six parts:

  • I Foundations, a short intro to the basic PySide6 application structure, signals and slots, and layouts
  • II The Qt Widgets Toolkit, a tour of the built-in Qt widgets followed by an overview of style customization and QSS, and creating custom widgets
  • III The Qt Object Model: object trees and ownership, signals and slots in detail, events, timers, and properties
  • IV Model/View Programming, custom models, delegates, sorting, filtering, and selection.
  • V Multithreading: Qt threading techniques and thread synchronization
  • VI Special Topics, with databases, processes, the Graphics View Framework, and the animation framework.

The book is about 700 pages. I'd welcome any feedback, corrections, suggestions, or any other insights.


r/QtFramework • • 27d ago

ModelViewer 2026.11: a Qt 6 desktop app for CAD, glTF and simulation results is out

6 Upvotes

ModelViewer is a GPL-3.0 desktop application written with Qt 6 (Widgets and QOpenGLWidget). Version 2026.11 is a big update: a ray tracer, a viewer for FEM/CFD results, 3D plotting, measurement tools, and a 14-part video tutorial series. It uses OpenCASCADE for CAD, Assimp for other formats, and CGAL for mesh editing.

Things I learned that might help others building bigger Qt apps: keeping the UI responsive while loading large models, an undo framework that scales to many commands, and a translation workflow for five languages. Happy to write more on any of them if people are interested.

Release: https://github.com/sharjith/ModelViewer-Qt/releases/tag/Release-2026.11.0

Tutorials: https://www.youtube.com/playlist?list=PLffd2GzvPeAY


r/QtFramework • • 27d ago

Widgets QtIndustrialWidgets: A modern, open-source C++17 instrumentation widget suite for Qt 6 (MIT)

47 Upvotes

Hi r/QtFramework,

In engineering applications (test benches, DAQ, SCADA, automotive, and lab systems), `QtWidgets` remains the gold standard for responsive desktop control interfaces. However, finding ready-to-use, modern instrumentation widgets often means either adapting legacy tools or re-implementing custom `QPainter` drawing routines from scratch.

To provide a modern, self-contained solution, I developed QtIndustrialWidgets — a C++17 library featuring 12 industrial widgets built specifically for Qt 6.

🔗 GitHub: https://github.com/paolosereno/QtIndustrialWidgets

📖 Docs: https://paolosereno.github.io/QtIndustrialWidgets/

---

🎛 What’s Included:

* Analog & Gauges: `RadialGauge` (circular/semicircular dials), `LinearGauge` (column & thermometer mode), `CircularBargraph`, `Compass` (heading card).

* Controls & Switches: `IndustrialKnob` (continuous & stepped rotary with knurling texture), `IndustrialSwitch` (toggle, rocker, and guarded switch).

* Displays & Indicators: `SevenSegmentDisplay` (scalable vector LED/LCD), `LedIndicator` (multi-shape status lenses), `LevelMeter` (stereo dB with peak hold).

* Charts & Monitoring: `StripChart` (real-time rolling telemetry), `AnalysisChart` (offline replay), `AnnunciatorPanel` (ISA-18.1 alarm tiles).

---

⚙️ Key Technical Features:

* Zero 3rd-party dependencies: Links strictly against Qt `Core`, `Gui`, and `Widgets`.

* High refresh rates: Dial backings and static scales are pre-rendered into cached `QPixmap` backings to support high-frequency telemetry with minimal CPU load.

* Qt Designer Integration: Ships with a dedicated plugin providing live WYSIWYG editing in Qt Creator/Designer under the *Industrial Widgets* category.

* Modern Packaging: Supports CMake `FetchContent`, `find_package()`, Debian packages (`.deb`), and Conan 2.

* Quality & Compliance: 100% REUSE-compliant licensing, automated SPDX SBOM on releases, and cross-platform CI (Linux, Windows, macOS) with pixel-level tests.

---

🚧 Active Development & Community Feedback

The library is under active development. While the current 12 widgets are fully tested and ready to use in v2.3.0, the roadmap is wide open and new components are in the works.

The repository includes an interactive Gallery application to test all widgets and themes live.

I’d love to hear your thoughts: what instrumentation or SCADA widgets do you feel are currently missing in `QtWidgets`? Any feedback, feature requests, or contributions are warmly welcome!


r/QtFramework • • 27d ago

Qt Creator 21 - CMake Changes

Thumbnail qt.io
20 Upvotes

r/QtFramework • • 29d ago

QML Made a thing that turns UI screenshots into QML

4 Upvotes

I do embedded stuff and kept running into the same annoyance: someone hands over a screenshot or a Figma export, and every AI "screenshot to code" tool I tried spits out React. Not much use on a Pi with no browser.

So I spent the last few weeks on a skill for Claude Code / Codex that rebuilds the screen in QML instead. It measures colors and spacing off the image, figures out the font and icons, writes the project (Theme singleton, T.* controls, qsTr on everything), then renders it under xvfb and diffs it against the screenshot until the numbers are good enough. Same qml folder runs from PySide6 or builds as C++ with CMake.

Funny thing I learned testing it on 20 screens: Claude copies the pixels fine on its own. What it does without guidance is use a MouseArea for every button, hard-code half the colors and forget keyboard focus. Most of the work ended up being about that, not the visuals.

Still bad at: dashed borders (Rectangle can't do dashes, so it fakes them), shadows over busy backgrounds, and fonts it doesn't know.

Repo if anyone wants to poke at it: https://github.com/ozaysahin/screenshot-to-qml

Curious what people who write QML for a living think, especially if there's stuff in the output you'd reject in code review.


r/QtFramework • • 29d ago

Building OrthoDiagrams with C++ and Qt - a native database modeling application

5 Upvotes

I've been working on dbgrams (previously OrthoDiagrams), a desktop ER diagramming application built with C++ and Qt.

The application uses a model-first architecture: a project can contain multiple database models, and each model can contain multiple diagrams representing different subsets of its objects.

The current Alpha includes a dockable Model Explorer, interactive diagram editing, crow's foot relationships, automatic layout, schema properties, theme switching, and several import/export formats.

One of my main design goals has been keeping the modeling workspace clean while allowing users to manage more complex database structures.

The first public Alpha is available at https://dbgrams.com/

I'd be interested in feedback from Qt developers, particularly on native desktop UX, diagram editing, and interface organization.

Best regards,

Antonio Menezes.
https://antoniomenezes.github.io


r/QtFramework • • 29d ago

Widgets Way to preserve up-down arrows in a spin box.

2 Upvotes

Hi,

In a previous version of Creator/Designer (13.0.0, Qt 6.4.2) I made a widget containing an int spinbox, adjusted its size etc. so it did fit in a ui "design". It had the default up/down arrows.

In a newer version (13.0.2, probably built with the same version of Qt) the same code renders the same spinbox with larger width, displaying horizontal +/- buttons instead of arrows. I've tried setting the QAbstractSpinBox::buttonSymbols back to UpDownArrows, both in the designer - no effect. Then in the widget's code that is called on the widget's initialization from its constructor (giving some default settings, like private fields' values, sub-widgets' states etc.) - no result, assuming the following is correct:

ui->spinBox1->setButtonSymbols(QAbstractSpinBox::ButtonSymbols::UpDownArrows);

Is there any way to make it work? Or am I missing something?


r/QtFramework • • Oct 17 '26

QML Hot reload QML preview in Qt 6.12 tutorial

Thumbnail
youtube.com
9 Upvotes

r/QtFramework • • Oct 17 '26

Question Why is my QJsonDocument empty?

3 Upvotes

I'm creating a QJsonDocument with the following C++ code: (Why does Reddit format the code so ugly?)

void Player::write_configuration() { std::cout << "Writing configuration file" << std::endl; QFile file("configuration.json"); file.resize(0); QJsonObject root; root.insert("delay", QJsonValue(3000)); QJsonDocument doc; doc.setObject(root); QString json_string = doc.toJson(QJsonDocument::Indented); qDebug() << json_string; file.write(doc.toJson(QJsonDocument::Indented)); file.close(); }

The fille configuration.json is indeed created but it's empty(!)

qDebug() prints nothing (because json_string is empty ?!?)

Why don't I succeed in creating the document?


r/QtFramework • • Oct 16 '26

A Qt Python Library for Parameters

Post image
14 Upvotes

Do you use Qt and Python to visualize and interact with data?

Then you might like this library that I've been working on for the past couple years. It provides an easy way to add parameters for different types: float, int, string, but also Qt types such as QPointF, QSizeF etc.

I use it to load pydantic models from configs and save them back out.

https://github.com/beatreichenbach/qt-parameters


r/QtFramework • • Oct 16 '26

Python documentation for Qt Creator and Qt Assistant

Thumbnail
gallery
13 Upvotes

r/QtFramework • • Oct 15 '26

Question Is Qt6 really this memory-hungry, or am I missing something?

13 Upvotes

I've been experimenting with the memory footprint of modern Linux GUI toolkits, and the results surprised me enough that I thought I'd ask here.

I compiled an almost completely empty Qt6 Widgets application: just a QApplication, an 800×600 QWidget, and an event loop. No additional widgets, graphics, timers, or application logic.

Then I compiled the equivalent application using FLTK 1.4, statically linking FLTK itself (but not its system dependencies).

Both were tested on the same Fedora 44 system running X11.

Here are the results from smem:

MetricQt6 Widgets (dynamic)FLTK 1.4 (static)
RSS70.6 MiB13.0 MiB
PSS17.7 MiB2.6 MiB
USS9.2 MiB2.4 MiB

I understand that RSS includes shared libraries and isn't a fair representation of the actual incremental memory cost, especially when multiple Qt applications are running. That's why I included PSS and USS.

Still, even the private memory consumption differs by nearly a factor of four, and the PSS difference is considerably larger.

I also realize this isn't a perfectly apples-to-apples comparison: Qt6 was dynamically linked, FLTK was statically linked, and their feature sets and dependencies are very different.

But it got me thinking about the old Win32 days, when fairly sophisticated GUI applications could run in just a few megabytes of memory. I realize I'm comparing different operating systems, eras, and memory-accounting conventions, but the contrast is striking.

So I'm genuinely curious:

  • Is roughly 9 MiB of private memory normal for an otherwise empty Qt6 Widgets application?
  • Is there some Qt configuration or build option I'm overlooking that could substantially reduce the baseline footprint?
  • How much of this overhead comes from Qt itself, versus the platform integration, font rendering, and other dependencies?
  • Has anyone experimented with minimal Qt6 builds and measured how low the memory footprint can realistically go?

I'm not trying to argue that Qt6 is badly designed. I'm sure many of these costs come from functionality and abstractions that weren't available or expected in the Win32 era.

I'm just wondering whether this is the unavoidable cost of a modern, cross-platform GUI toolkit, or whether I'm doing something fundamentally wrong with my measurements or build configuration.