Author: Thorsten Geppert

What’s new in Qt 6.10? A developer’s overview

Thorsten Geppert Leave a comment

Qt 6.10 is one of those releases that doesn’t radically change how you build Qt applications, but smooths out many edges that mattered in day‑to‑day work: accessibility, layouting, vector animations, data integration between C++ and QML, and developer ergonomics around models and bindings.

Here is a structured overview of the key changes in Qt 6.10, based on the official release information.

Accessibility: High‑contrast and assistive tech

Qt 6.10 makes a noticeable push on accessibility:

  • High‑contrast mode across platforms:
  • Built‑in styles now better respect system‑level high‑contrast settings on major platforms.
  • The goal is for Qt applications to visually align with the rest of the OS environment while improving readability.
  • As an application developer, you get better contrast behavior essentially “for free” when users enable high‑contrast mode at the OS level.
  • Improved integration with assistive technologies:
  • Qt Widgets and Qt Quick Controls have been refined to present themselves more cleanly to assistive technology clients such as screen readers.
  • The WebAssembly platform in particular benefits from better accessibility integration.
  • Many of these changes are also being back‑ported to LTS branches via patch releases.

In short: Qt 6.10 helps you get closer to accessibility requirements without forcing you to add platform‑specific hacks everywhere.

Qt Quick: FlexboxLayout and modern UI building blocks

Qt Quick continues to evolve as the main UI technology. Qt 6.10 introduces several notable features.

FlexboxLayout (Tech Preview)

  • New FlexboxLayout type for Qt Quick, inspired by CSS Flexbox.
  • Benefits:
  • More natural behavior on screens with varying sizes and aspect ratios.
  • Less custom layout code for responsive UIs.
  • Familiar mental model for developers coming from web/CSS.
  • Integration:
  • Integrates with the existing Qt Quick layout system (attached properties etc.).
  • Currently a technology preview, so the API may still change before the next LTS release.

Animated vector graphics (SVG & Lottie)

Qt 6.10 builds on the vector/SVG improvements introduced in earlier 6.x releases:

  • VectorImage (introduced in 6.8) is extended:
  • Supports animated vector graphics in
    • SVG format, and
    • Lottie format.
  • Qt Lottie module:
  • Improved support for modern Lottie files.
  • Lottie assets can now be rendered as scalable, hardware‑accelerated vector graphics directly in the Qt Quick scene graph.

For designers and UI developers, this makes it much easier to bring rich motion design from tools like Figma/After Effects (via Lottie) into Qt applications.

New Quick Control: SearchField

  • Specialized control for search input.
  • Provides:
  • Native look and feel on all major platforms, like other Qt Quick Controls.
  • A built‑in suggestion popup driven by a model (e.g., QAbstractItemModel or QML models).
  • Works particularly well with the new data/model helpers described below.

Making C++ ↔ QML data integration easier

Bridging C++ backend logic and QML/Qt Quick UIs has always been powerful but sometimes verbose. Qt 6.10 adds several features to reduce boilerplate.

QRangeModel: use C++ ranges directly as models

  • QRangeModel is a lightweight QAbstractItemModel implementation designed to expose C++ ranges (e.g. std::vector, std::array, or other iterable containers) as models.
  • Capabilities:
  • Handles both simple values (ints, strings, …) and more complex types (GADGETs, std::tuple, etc.).
  • Automatically defines roles for the data it exposes.
  • Works with both Qt Widgets views and QML/Qt Quick views.

In many common cases, this removes the need to implement custom QAbstractItemModel subclasses just to show a C++ container in a view.

delegateModelAccess: writing back to the model is less awkward

Previously, writing from a delegate back into the model often required:

  • Directly accessing the model object in the delegate, or
  • Using context properties and custom signal/slot code.

In Qt 6.10, views can set delegateModelAccess: DelegateModel.ReadWrite, which allows required properties in delegates to write back into the model directly. This fits nicely with the recommended pattern of using required properties for model data and reduces glue code in larger QML UIs.

Synchronizer: two‑way and multi‑way bindings

  • New Synchronizer element (Tech Preview, in the Qt.labs.synchronizer module).
  • Purpose:
  • Keep multiple properties in sync as far as possible, without breaking their individual bindings.
  • Works with properties implemented in C++ or QML.
  • Practical impact:
  • Common patterns like “control ↔ model value” can be expressed declaratively without extra signal handlers.

QML TreeModel

  • New TreeModel QML type for declaring tree data structures directly in QML.
  • Targeted at:
  • Prototyping,
  • small datasets,
  • and situations where a full C++ tree model layer would be overkill.

Taken together, these features make the boundary between C++ backends and QML frontends more comfortable to work with.

Qt Graphs: new FilledSurface graph and more

Qt Graphs continues to evolve in Qt 6.10:

  • New graph types and refinements:
  • One notable addition is the “FilledSurface” graph type, useful for visualizing filled surfaces.
  • Better integration with Qt Quick and the new layout/vector features.

If you are already using Qt Graphs, it is worth checking the module‑specific release notes for details.

Other improvements and platform updates

As always, Qt 6.10 comes with a wider set of refinements:

  • Platform integration:
  • Official support aligns with current versions of major desktop, mobile, and embedded platforms (see the release note and wiki for specifics).
  • Bug fixes and polish:
  • Numerous bug fixes across modules (Widgets, Quick, Network, etc.).
  • The detailed release notes for 6.10.0–6.10.2 list the low‑level changes.

Conclusion

Qt 6.10 is not a disruptive release, but it addresses many things that matter in real projects:

  • Accessibility (high‑contrast mode, assistive technology integration) gets first‑class treatment.
  • Qt Quick gains modern layout and UI capabilities with FlexboxLayout, animated vector graphics, and the SearchField control.
  • C++↔QML integration becomes less verbose and more declarative, thanks to QRangeModel, delegateModelAccess, Synchronizer, and TreeModel.

If you are already on Qt 6.x, Qt 6.10 is especially interesting if:

  • accessibility and regulatory compliance are relevant,
  • you want richer, animated UIs using vector/Lottie graphics,
  • or your current C++↔QML integration feels heavy on glue code.

References

  • Qt Blog: Qt 6.10 Released! – https://www.qt.io/blog/qt-6.10-released
  • Qt Wiki: Qt 6.10 Release – https://wiki.qt.io/Qt_6.10_Release
  • Qt Documentation: New Features in Qt 6.10 – https://doc.qt.io/qt-6.10/whatsnew610.html

FreeBSD in the Last Seven Days: Between 14.4 Reality, ZFS Concerns, and Small pkg Ideas

Thorsten Geppert Leave a comment

Those waiting for FreeBSD to make a big splash often wait a long time. That’s one of the things I both appreciate and occasionally find frustrating about the system. I appreciate it because you’re not bombarded with marketing hype every other day. But it’s frustrating because you often have to piece together the most interesting developments from mailing lists, release notes, and passing remarks.

Looking back at the past seven days, the core picture is quite typical for FreeBSD: outwardly, it’s relatively quiet, but beneath the surface, discussions are happening in precisely the areas that make operating systems either pleasant or frustrating in daily use—software build performance, ZFS stability and memory behavior, and how to make pkg more practical in a PKGBASE environment.

FreeBSD 14.4 Remains the Dominant Topic

The most important official news in the observed period is still the release of FreeBSD 14.4-RELEASE on March 10. While it falls just outside the seven-day window, it has clearly shaped discussions this week—and for good reason.

Key highlights of 14.4 include:

  • OpenSSH 10.0p2
  • Hybrid post-quantum algorithm mlkem768x25519-sha256 enabled by default
  • OpenZFS 2.2.9
  • Improved cloud-init/nuageinit compatibility
  • A new p9fs(4) for filesystem sharing between host and bhyve guests
  • Enhancements to manpages and their tools

Overall, this is a solid release. No revolution, but exactly the kind of version FreeBSD is known for: evolutionary, pragmatic, and focused on meaningful maintenance rather than spectacle.

Also worth mentioning is the dedication of this release to Ken Smith, who passed away late last year and played a key role in FreeBSD’s release engineering for many years. Such acknowledgments often get lost in technical announcements, but they matter—they remind us that behind all the code, there are people.

Early Feedback on 14.4: Build Times Cause Frustration

More interesting than the release announcement itself were this week’s real-world reports. On the mailing list, a case was described where, after upgrading from 14.3 to 14.4, build times with poudriere had increased—sometimes doubling in duration.

This isn’t a minor detail. For those who build ports, maintain packages, or compile locally, this isn’t just a cosmetic issue—it’s a daily pain. If a full build suddenly takes two days instead of one, that’s no longer a footnote.

The discussion pointed to a known performance issue and noted that a workaround exists to restore the previous behavior. That’s the good news. The less good news is that such problems only surface in practice, and users have to dig through threads and commit messages to find solutions.

This is, unfortunately, not uncommon with FreeBSD: the technology is often solid, but communication about it can be less user-friendly than it could be.

ZFS Remains Excellent—and Sometimes Frustrating

Things got really interesting in a discussion about ZFS deadlocks and memory accounting issues on NFS servers. A scenario was described where machines, despite having plenty of free RAM, came under memory pressure, started swapping, and in the worst cases, hit OOM (out-of-memory) conditions. This is particularly frustrating because large storage and file-serving systems running FreeBSD are often chosen precisely because ZFS is supposed to excel in such environments.

The reported case involved systems with very high RAM capacity, where ARC memory appeared evictable, yet the system still entered a problematic state. There were also reports of blocked processes and wait states around ARC and dbuf mechanisms. Of course, this is just one case from a mailing list—not a universal statement about all 14.x installations. But it’s exactly the kind of signal that should make administrators take notice.

Such issues aren’t problematic because they’re spectacular; they’re problematic because they often disguise themselves as “odd behavior” for a long time. A little swap here, some load there, a few hanging processes—and suddenly, a system that, by superficial metrics, shouldn’t be struggling at all, is in trouble.

FreeBSD still has strong arguments in the storage space. But when reports like this emerge, they should be taken seriously—not hysterically, but seriously.

A Small pkg Discussion, But with Practical Relevance

Less dramatic but still practically relevant was a discussion about pkg and its interaction with PKGBASE. Specifically, the desire to cleanly separate upgrades for third-party packages and the base system.

Proposed additions included aliases like:

  • pkg upgrade-packages
  • pkg upgrade-base

The idea is simple and reasonable: in daily use, users don’t always want to lump everything together. Instead, they want to consciously decide whether to update only ports packages or only the base system.

This isn’t the kind of news that inspires excitement, but it’s a good example of how FreeBSD evolves: often in small, unassuming, yet practical steps. In the end, such improvements often make more of a difference than some grand, heavily promoted project.

At the same time, the discussion highlights a typical problem: naming and clarity aren’t trivial. If you say “packages” when, technically, everything is a package, confusion is almost built in. It’s not a disaster, but it’s not a detail that should be ignored either.

What Stands Out from This Week?

Summing up the past seven days around FreeBSD, this is the picture that emerges:

FreeBSD often appears quiet—almost too quiet—on the surface. But beneath that calm, the discussions revolve around precisely the issues that matter most to users and administrators:

  • How well does a new release perform in real-world use?
  • Are there performance regressions?
  • Is ZFS as stable under real-world load as expected?
  • Are tools like pkg becoming more usable in daily operations?

That, in the end, might be what’s most likable about FreeBSD. The most interesting news is rarely just “New! Bigger! Faster!” Instead, it’s often about where practice clashes with theory—and that’s where a system earns long-term trust.

14.4-RELEASE is undoubtedly the most significant recent development. But the subsequent discussions about build performance and ZFS show that a release isn’t finished when it’s published. That’s when the phase begins where it becomes clear how well things actually work outside of release notes and announcements.

And that phase was the truly interesting part of the last seven days.

Sources

  • FreeBSD News Flash: https://www.freebsd.org/news/newsflash/
  • FreeBSD News RSS Feed: https://www.freebsd.org/news/feed.xml
  • FreeBSD 14.4-RELEASE Announcement: https://lists.freebsd.org/archives/freebsd-announce/2026-March/000228.html
  • FreeBSD-announce Archiv März 2026: https://lists.freebsd.org/archives/freebsd-announce/2026-March/date.html
  • Thread: „Huge build times increase after updating from 14.3 to 14.4“: https://lists.freebsd.org/archives/freebsd-stable/2026-March/003900.html
  • Antwort von Olivier Certner zum bekannten Performance-Problem: https://lists.freebsd.org/archives/freebsd-stable/2026-March/003901.html
  • Nachfrage von Philip Paeps zu den Package-Buildern: https://lists.freebsd.org/archives/freebsd-stable/2026-March/003907.html
  • Thread: „ZFS deadlocks/memory accounting issues“: https://lists.freebsd.org/archives/freebsd-stable/2026-March/003910.html
  • Antwort von Alan Somers im ZFS-Thread: https://lists.freebsd.org/archives/freebsd-stable/2026-March/003911.html
  • Thread/Proposal zu pkg-Aliases: https://lists.freebsd.org/archives/freebsd-stable/2026-March/003942.html
  • Rückfrage zur Benennung der pkg-Aliases: https://lists.freebsd.org/archives/freebsd-stable/2026-March/003944.html
  • FreeBSD-stable Archiv März 2026: https://lists.freebsd.org/archives/freebsd-stable/2026-March/date.html

Why I Use FreeBSD Instead of Linux on Servers

Thorsten Geppert Leave a comment

When it comes to server operating systems, most people immediately think of Linux. That makes sense: Linux is widely used, has a large ecosystem, and is the default choice in many companies.

Despite that, I have preferred working with FreeBSD for many years. I first started using it around the time of FreeBSD 4, and since then it has remained my first choice for many of the systems I run.

Why?

The short answer: FreeBSD feels like a coherent operating system, while many Linux installations feel more like a collection of separate components.

The longer answer is a bit more interesting.

A complete operating system

One of the main differences between Linux and FreeBSD lies in how the system is structured.

Most Linux distributions are built from components developed by many independent projects:

  • the Linux kernel
  • GNU userland tools
  • an init system
  • a package manager
  • additional utilities and frameworks

This works well, but it can sometimes lead to inconsistencies between distributions.

FreeBSD takes a different approach. The base system is developed and maintained as one integrated operating system.

The kernel, system utilities, and core components belong together and are released together. As a result, the system feels very consistent in configuration, behavior, and documentation.

This becomes especially valuable when you run servers for many years.

Predictable behavior

One of the most important qualities of a server operating system is predictability.

Servers should ideally be boring: they should run reliably, behave consistently, and not surprise you after updates. Like an aircraft.

In my experience, FreeBSD systems tend to do exactly that. Once properly configured, they usually run quietly in the background for long periods of time.

Updates are generally straightforward, and the system behaves in ways that are easy to understand and anticipate.

For infrastructure that is meant to run for years, this reliability matters a lot.

ZFS as a first-class citizen

Another major reason I appreciate FreeBSD is its excellent integration with ZFS.

ZFS offers features that are extremely useful in everyday server administration:

  • snapshots
  • simple backup strategies
  • data integrity
  • flexible storage layouts

For servers handling large amounts of data or running multiple services, ZFS can significantly simplify storage management.

Many of my systems rely on ZFS as the foundation for both storage and backup strategies.

Jails: lightweight service isolation

FreeBSD provides Jails, a very elegant mechanism for isolating services.

Compared to full virtual machines, Jails are extremely lightweight. They allow services to run in isolated environments without requiring a complete operating system for each instance.

This has several advantages:

  • lower resource usage
  • clear separation of services
  • simpler administration

For many server setups, this approach is both efficient and easy to maintain.

Clear structure and solid tooling

Another aspect I appreciate about FreeBSD is the clarity of its system design.

Examples include:

  • the traditional rc system for service management
  • a consistent configuration approach
  • the pkg package management system
  • excellent man pages and documentation

When you return to a system months or years later, this clarity makes it much easier to understand how everything fits together.

Practical experience

My preference for FreeBSD is not theoretical.

Over the years I have run many systems based on FreeBSD, including servers providing services such as:

  • web applications
  • databases
  • DNS, DHCP, and NTP
  • NFS and Samba
  • various applications running inside Jails
  • Bhyve as virtualization platform

Some of these systems also involve more complex storage setups using ZFS or virtualization with bhyve.

This long-term practical experience is the main reason why FreeBSD remains my preferred platform for many server workloads.

Conclusion

Linux is an excellent operating system and a great choice in many situations.

However, for many of my own server deployments I still prefer FreeBSD.

The main reasons are:

  • a coherent and well-integrated operating system
  • predictable and stable behavior
  • excellent ZFS integration
  • lightweight isolation with Jails
  • a clear and consistent system design

Especially for long-running infrastructure, FreeBSD has repeatedly proven itself to be a robust and dependable platform.

Which problems do I solve – and for whom?

Thorsten Geppert Leave a comment

I am frequently asked what exactly it is that I do. The short answer: I develop software and administrate systems, mainly those under FreeBSD. The longer answer is this post.

My occupation moves in between software development, infrastructure and system architecture. I help with constructing systems or stabilizing them in order for them to work long-term – technically sound, comprehensible and maintainable.

Software Development: Quality instead of quantity

In my blog articles about software development I wrote a lot about what goes wrong in companies: Unreadable code, missing architecture, technical debts that no one touches anymore, and the focus on processes instead of the product itself. This is no abstract critique, but things that I, over the course of many years in different companies, experienced up close and personal.

The result is what I offer: Clean, comprehensible and maintainable software. Code that can still be understood by someone in five years. I have acquired a lot of experience in different programming languages – from system-oriented programming up to complex GUI-Applications with Qt and wxWidgets. Databases (especially PostgreSQL) as well as client-server architecture and network programming are also included.

If you manage a project that went off the rails, which was developed by one singular person and that no one can make sense of now or if you are in the desperate need of a new architecture- then I am the right person to turn to.

FreeBSD-Administration: Stable, secure, thought-through

FreeBSD has been with me since Version 4, which means since over two decades. My own servers run on it, I have experience with ZFS with RAIDz, FreeBSD-Jails, Bhyve, pf, CARP, HAST and the common network services (DNS, DHCP, NTP, NFS, Samba, LDAP and others) because of daily practice – not only through documentation.

What I solve and what I offer: You need a stable, secure server or a scalable server infrastructure under FreeBSD? You want to isolate services in Jails? You manage a running system that is in need of care or extension, expansion or add-ons? Or you stand before a specific problem that seems without solution?
I am fairly acquainted with such situations – and in finding pragmatic solutions.

For companies

If you are reading this in the interest of a company: I merge software development with system administration. I am no specialist who tweaks only one screw but someone who understands systems as a whole. I have worked in companies were both were of importance and I know of the relevance of development and infrastructure fitting together to paint the whole picture.

I appreciate a corporate culture in which mistakes are understood as a learning opportunity, skills are used sensibly and where the product is the main focus – not the management of tickets. If you share these views, we should talk: thorsten@tgeppert.de.