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.

FreeBSD Changes and Updates – Week of April 4, 2026

admin Leave a comment

Executive Summary

FreeBSD 14.4-RELEASE, announced on March 10, 2026, represents a significant milestone in the stable/14 branch with substantial improvements in security, virtualization, and cloud integration. This comprehensive overview covers the latest developments, security advisories, and technical enhancements in the FreeBSD ecosystem.

FreeBSD 14.4-RELEASE: Major Features

OpenSSH 10.0p2 with Post-Quantum Cryptography

The most notable security enhancement in FreeBSD 14.4 is the upgrade to OpenSSH 10.0p2, which introduces:

Hybrid Post-Quantum Algorithm: Default use of mlkem768x25519-sha256, combining traditional elliptic curve cryptography with post-quantum Kyber-based algorithms
Enhanced Key Exchange: Protection against future quantum computing threats while maintaining compatibility with existing infrastructure
Improved Authentication: Stronger security posture for SSH connections in enterprise environments

OpenZFS 2.2.9 Storage Enhancements

The OpenZFS filesystem receives significant updates:

Performance Improvements: Optimized ARC implementation and reduced memory overhead
Metadata Handling: Faster directory operations and improved metadata caching
Compression Enhancements: Better zstd compression ratios and performance
Snapshot Management: More efficient incremental send/receive operations

bhyve Virtualization: p9fs Integration

A groundbreaking feature for virtualization environments:

9P Filesystem Support: Native implementation of the 9P2000 protocol (p9fs) enables direct filesystem sharing between bhyve hosts and guests
Usage Examples:

# Mount p9fs share in guest
mount -t virtfs sharename /mnt

# Use as root filesystem (advanced)
vfs.root.mountfrom="p9fs:sharename" in /boot/loader.conf

Benefits: Simplified file sharing, reduced overhead compared to NFS/SMB, and improved security through protocol isolation

Cloud Integration: nuageinit Improvements

Enhanced cloud-init compatibility addresses enterprise deployment needs:

Better Metadata Handling: Improved parsing of cloud provider metadata formats
Network Configuration: More reliable network interface configuration in cloud environments
User Data Processing: Enhanced support for cloud-init user-data scripts and configurations

Security Enhancements

Encrypted Swap Support: Native encryption of swap space using geli(8) encryption system
Jail Security: Improved isolation and resource controls for FreeBSD jails
MAC Framework: Enhanced Mandatory Access Control policies and utilities

Recent Security Advisories

FreeBSD-SA-26:09.pf (March 26, 2026)

Severity: High
Affected Versions: FreeBSD 14.x, 15.0
CVE: CVE-2026-4652

Issue: The pf firewall silently ignores certain rule configurations, potentially allowing unintended network access

Resolution:

  • Patches available for all supported branches
  • Immediate upgrade recommended via:
freebsd-update fetch
freebsd-update install
# Or using packages
pkg upgrade

Workaround: Temporarily rewrite affected rules using tables or labels instead of direct interface specifications

FreeBSD-SA-26:07.nvmf (March 25, 2026)

Severity: Medium
Affected Versions: FreeBSD 15.0

Issue: Security vulnerability in NVMe over Fabrics subsystem implementation

Patches Released:

  • stable/15 branch: March 25, 2026 01:29 UTC
  • releng/15.0 branch: March 26, 2026 01:11 UTC

Ports and Packages Updates

pkgsrc-2026Q1 Branch (March 27, 2026)

The new quarterly branch brings:

Software Updates: Latest versions of popular applications and libraries
Security Fixes: Patches for vulnerable packages in the ports collection
Dependency Resolution: Improved handling of complex dependency chains

Notable Package Upgrades

  • OpenSSL 3.5: Multiple security fixes and performance improvements
  • PostgreSQL 17: Enhanced query optimization and replication features
  • Python 3.12: New language features and runtime optimizations
  • pkg 2.6.2_1: Improved package management with better dependency resolution

Development and Community News

Google Summer of Code 2026

FreeBSD has been selected for Google Summer of Code 2026, with focus areas including:

Kernel Development: Performance optimization and new driver support
Tooling Improvements: Enhanced developer tools and debugging utilities
Documentation: Comprehensive documentation updates and translations

Release Engineering Changes

The FreeBSD project has adopted a new release strategy:

Quarterly Releases: Every 3 months for regular feature updates
Biennial Releases: Every 2 years for long-term support versions
Benefits: More predictable release cycles, better security maintenance, and improved stability

System Administration Guidance

Upgrade Recommendations

For systems running FreeBSD 14.x:

# Standard upgrade process
freebsd-update fetch
freebsd-update install

# Rebuild third-party packages if necessary
pkg upgrade

Security Best Practices

  1. Regular Updates: Schedule weekly security update checks
  2. Firewall Review: Audit pf rulesets for potential issues
  3. Monitoring: Implement comprehensive system monitoring
  4. Backup Strategy: Ensure regular ZFS snapshots and offsite backups

Performance Monitoring Commands

# ZFS performance
zpool iostat -v 1
zfs get all poolname

# Network monitoring  
pfctl -s info
pfctl -s rules

# System health
vmstat 1
iostat 1

Support Timeline

FreeBSD 14.4-RELEASE: Supported until December 31, 2026
FreeBSD 13.x: Entering end-of-life phase, migration to 14.x recommended
FreeBSD 15.0: Current development branch, production use with caution

International Security Notices

BSI (Germany): Multiple advisories regarding FreeBSD vulnerabilities
Canadian Centre for Cyber Security: AV26-179 advisory for critical fixes
DFN-CERT: DFN-CERT-2026-0689 covering local privilege escalation issues

Resources and References

  • Official Security Advisories: https://www.freebsd.org/security/advisories/
  • Release Notes: https://www.freebsd.org/releases/14.4R/relnotes/
  • Mailing Lists: https://lists.freebsd.org/
  • Community Support: https://forums.freebsd.org/
  • Documentation: https://docs.freebsd.org/en/books/handbook/

Upcoming Events

  • FreeBSD Developer Summit: April 15-16, 2026 (Virtual)
  • Google Summer of Code: Coding period begins May 1, 2026
  • Next Quarterly Release: FreeBSD 14.5 expected June 2026

In‑Depth Comparison of the BSD Family: FreeBSD, OpenBSD, NetBSD, and DragonFlyBSD

admin Leave a comment

Table of Contents

  1. Introduction and History
  2. Philosophy, Development Model and Licensing
  3. Typical Use Cases – Where Each BSD Excels
  4. Kernel Architecture in Detail
  1. Derivatives, Specialty Distributions and Ecosystem
  2. Pros and Cons Tables – Quick Comparison
  3. Decision Guide – Which BSD Fits Your Project?
  4. Future Roadmaps and Development Plans
  5. References, Further Reading and Community Links

Introduction and History

The BSD family originates from the Berkeley Software Distribution released by the University of California, Berkeley, in 1977. The early releases (1.0 – 4.3BSD) introduced the now‑ubiquitous TCP/IP stack, a pivotal innovation that turned BSD into the backbone of the modern Internet.

During the early 1990s the project split into several independent branches, each pursuing a distinct vision:

  • FreeBSD (founded 1993) focused on performance, stability and a massive Ports collection for third‑party software.
  • OpenBSD (branched off 1995) adopted a strict security‑first policy, aiming to be the most secure UNIX‑like OS.
  • NetBSD (1993) embraced portability, coining the slogan “runs on anything” – it now supports more than 50 CPU architectures.
  • DragonFlyBSD (2003) forked from FreeBSD 4.8 to address concerns about development speed and SMP scalability, culminating in a modern kernel and the HAMMER2 filesystem.

These divergent histories still shape the design decisions, community culture, and target workloads of each system today.

Philosophy, Development Model and Licensing

ProjectPrimary GoalDevelopment ModelLicense
FreeBSDHigh‑performance server & desktop platformCentral core team, Commit‑Access managed by a small Core Team; Ports tree maintained by a large pool of volunteers.BSD 2‑Clause + CDDL for ZFS (exception for the ZFS implementation)
OpenBSDMaximal security and code correctnessVery conservative, small team; each change undergoes extensive code audit before being committed.BSD 2‑Clause (pure, no additional encumbrances)
NetBSDPortability, clean code, support for exotic hardwareDecentralised, Git‑based repository; pkgsrc is a separate, cross‑platform package collection.BSD 2‑Clause
DragonFlyBSDScalable SMP performance, modern filesystemsSmall, focused core team; rapid six‑to‑eight‑week release cycles.BSD 2‑Clause

Licensing matters for enterprises. FreeBSD’s inclusion of the CDDL ZFS code can raise compliance questions, whereas OpenBSD, NetBSD and DragonFlyBSD remain under a single, permissive BSD licence.

Typical Use Cases – Where Each BSD Excels

Use caseFreeBSDOpenBSDNetBSDDragonFlyBSD
Web & DB servers★★★★★ – ZFS + Jails, highly tuned TCP stack (Fast Open, RACK) – used by Netflix, GitHub, Yahoo!★★★☆☆ – security‑first front‑ends, but fewer performance‑tuned features.★★☆☆☆ – rarely used as a primary web server; shines on embedded gateways.★★★★☆ – HAMMER2’s dedup & snapshots make it attractive for storage‑heavy workloads.
Firewalls / Routers★★★★☆ – pf (ported), ipfw, pfSense/OPNsense are FreeBSD‑based appliances.★★★★★ – pf originated here; excellent defaults, minimal footprint for pure firewall use.★★☆☆☆ – supports pf via ports, but lacks a native UI.★★☆☆☆ – no dedicated firewall framework.
Embedded / IoT★★☆☆☆ – ARM support exists, but larger footprint limits usage.★★★☆☆ – small, secure, but driver set lagging.★★★★★ – runs on ARM, MIPS, PowerPC, SPARC, RISC‑V; clean‑room builds ideal for deterministic firmware.★★☆☆☆ – focus remains server‑oriented.
Desktop / Workstation★★★★☆ – GhostBSD, MidnightBSD provide ready‑made GNOME/KDE environments.★★☆☆☆ – no official desktop flavour, though X11 is available.★★★☆☆ – NomadBSD (live USB) offers a minimal desktop.★★★★☆ – desktop installer exists but the project’s emphasis stays on server use.
NAS / Storage Appliances★★★★★ – ZFS native, TrueNAS CORE is built on FreeBSD.★★★☆☆ – ZFS ports exist but not a primary feature.★★★☆☆ – FFS with WAPBL, optional ZFS ports.★★★★★ – HAMMER2 provides copy‑on‑write, snapshots and dedup, suitable for backup servers.

Kernel Architecture in Detail

Filesystems and Storage

  1. FreeBSD – ZFS
  • Copy‑on‑Write, end‑to‑end checksumming, compression, deduplication, and native encryption. ZFS pools (zpool) allow mixing devices of different sizes and types. Integrated since FreeBSD 9.0, ZFS can be a root filesystem. The CDDL license of ZFS is the only non‑BSD component.
  1. OpenBSD – FFS + Soft‑crypto
  • Traditional Fast File System (UFS). No native ZFS; experimental ports exist. Encryption is handled via soft‑crypto (GELI) which provides block‑device level encryption.
  1. NetBSD – FFS + WAPBL
  • Uses WAPBL (Write‑Ahead Physical Logging) for low‑overhead journaling of metadata, striking a balance between performance and crash‑consistency.
  1. DragonFlyBSD – HAMMER2
  • Modern copy‑on‑write filesystem with snapshots, deduplication, and cluster‑level mirroring. Optimised for many‑core systems and large storage pools. Tooling is less mature than ZFS, but performance on multi‑core machines is excellent.

Network Stack and Security Features

  • FreeBSD: Highly tuned TCP stack (Fast Open, RACK, NewReno), ipfw as classic firewall, and pf (ported from OpenBSD) for modern packet filtering. BPF (Berkeley Packet Filter) provides fast packet capture for IDS/IPS.
  • OpenBSD: pf is the flagship firewall; the project emphasizes secure‑by‑default sysctl defaults, mandatory access controls, and frequent security audits. Integrated tools include OpenSSH, LibreSSL, OpenBGPD, and OpenNTPD.
  • NetBSD: Supports ipfilter, ipfw, and also pf via ports. The networking code is highly portable, making it ideal for edge routers on obscure architectures.
  • DragonFlyBSD: Includes pf and ipfw. The network stack is clean and well‑documented, though not as feature‑rich as FreeBSD’s implementation.

Virtualization, Containers and Isolation

SystemContainer TechnologyHypervisorNotable Features
FreeBSDJails – OS‑level containers with separate IP stacks, filesystem views, and resource limits (rctl).bhyve – modern hypervisor supporting virtio, UEFI, and KVM acceleration.runjail adds Docker‑compatible runtime, vmm module for hardware acceleration.
OpenBSDNone (no jail‑like facility).vmm – lightweight hypervisor with KVM compatibility.Security‑first design, minimal attack surface.
NetBSDNone (no built‑in container system).Xen, bhyve, hyper‑v support via kernel modules.Broad hardware support, but tooling is fragmented.
DragonFlyBSDVkernel – lightweight kernel instance for isolation, roughly comparable to a micro‑VM.—Vkernel enables fast, low‑overhead sandboxing, ideal for micro‑services.

Combining FreeBSD Jails with OpenBSD pf yields a powerful model: Jails give process isolation, while pf provides fine‑grained packet filtering and NAT.

Derivatives, Specialty Distributions and Ecosystem

DerivativeBase BSDTarget AudienceKey Characteristics
GhostBSDFreeBSDDesktop users (GNOME/KDE)One‑click installer, optional ZFS root, encrypted home directories.
MidnightBSDFreeBSDDesktop & entry‑level servermidnightbsd-install, graphical installer, own pkgsrc‑based package manager.
TrueNAS COREFreeBSDNAS applianceFull ZFS management UI, VM support, replication, commercial support available.
pfSenseFreeBSDFirewall / RouterRich plugin ecosystem (OpenVPN, IPSec, Captive Portal), web UI, optional commercial support.
OPNsenseFreeBSDModern firewallAngular‑based UI, IDS/IPS via Suricata, Let’s Encrypt integration, frequent security releases.
NomadBSDNetBSDLive USB + persistenceMinimal live system, easy to write changes back to flash, small image size.
OpenBSD‑based toolsOpenBSDSecurity utilitiesOpenSSH, OpenBGPD, OpenNTPD, LibreSSL – widely embedded in other distributions.
DragonFlyBSD‑BobDragonFlyBSDServer scalingMinimalist image focused on HAMMER2 performance, low overhead.

These derivatives allow teams to pick a pre‑packaged solution that matches their use case without building the entire OS from scratch.

Pros and Cons Tables – Quick Comparison

FreeBSD

ProsCons
Massive Ports collection (≈30 k packages)Larger footprint – less suitable for very constrained embedded devices
Native ZFS support (snapshots, dedup, encryption)License complexity (BSD + CDDL) can raise compliance concerns
Jails – lightweight OS‑level containers with resource limitsJails lack some features of Docker (e.g., overlay filesystem)
High‑performance network stack, pf and ipfw availableSome newer networking features lag behind Linux implementations

OpenBSD

ProsCons
Highest security focus (code audits, securebydefault)Limited driver support, especially for newer hardware
pf firewall engine – reference implementationNo native ZFS (only experimental ports)
Small, coherent code base – easy to auditSmaller ports tree, fewer third‑party packages
Integrated security tools (OpenSSH, LibreSSL, OpenBGPD)Security‑first approach can limit raw performance optimisations

NetBSD

ProsCons
Runs on >50 architectures – perfect for embedded & researchSmaller community, fewer commercial services
WAPBL offers low‑overhead journaling
Clean, modular kernel – easy to patch and extend
No native ZFS (only ports)
Lack of built‑in server‑centric features (no Jails, pf not default)
Documentation sometimes sparse for newcomers

DragonFlyBSD

ProsCons
HAMMER2 – modern COW filesystem with dedup and snapshots
Vkernel – lightweight isolation ideal for micro‑VMs
Strong SMP scaling – excellent on many‑core servers
Rapid release cycle, active development
Smaller community, limited commercial backing
HAMMER2 tooling less mature than ZFS

Decision Guide – Which BSD Fits Your Project?

RequirementRecommended BSDRationale
Maximum security (firewall, crypto, audits)OpenBSDpf originated here, LibreSSL, OpenSSH hardening, securebydefault defaults.
Enterprise storage (ZFS, snapshots, replication)FreeBSD (or TrueNAS CORE)Native ZFS, mature management tools, large community.
Broad hardware support (IoT, ARM, MIPS, SPARC, RISC‑V)NetBSDSupports >50 architectures, clean‑room builds, deterministic firmware.
Scalable SMP servers (many cores, dedup)DragonFlyBSDHAMMER2 dedup, Vkernel, excellent multi‑core performance.
Desktop experience (GNOME/KDE, plug‑and‑play)GhostBSD (FreeBSD) or MidnightBSDReady‑made installers, pre‑configured desktop environments.
Firewall appliancepfSense / OPNsense (FreeBSD‑based)Web UI, extensive plugin ecosystem, commercial support available.
NAS / storage applianceTrueNAS CORE (FreeBSD)Full ZFS UI, VM support, replication, enterprise features.
Research / developmentNetBSDPortability, pkgsrc works across many platforms.

When making a decision, also weigh community activity, package availability (Ports vs. pkg vs. pkgsrc), licensing constraints, and support options (mailing lists, issue trackers, commercial vendors).

Future Roadmaps and Development Plans

  • FreeBSD 15.x – Continued ZFS evolution (ZFS 2.2 with improved scrubbing and compression), GPU pass‑through for bhyve, tighter Kubernetes integration via csi‑freebsd.
  • OpenBSD 7.9 – pf engine enhancements, introduction of Trusted Execution Environments (TEE), expanded hardware root‑of‑trust mechanisms.
  • NetBSD 10 – Strong focus on RISC‑V support (new toolchains, device‑tree), pkgsrc extensions for container orchestration, modernised network‑stack libraries.
  • DragonFlyBSD 6 – Final stabilisation of HAMMER2, new Vkernel features (namespace isolation, cgroup‑like limits), optional ZFS ports for hybrid setups.
  • Derivatives: TrueNAS SCALE (Debian‑based) challenges the FreeBSD‑based CORE, while pfSense 2.8 adds eBPF support for advanced packet processing pipelines.

References, Further Reading and Community Links

  • FreeBSD Project – Official Documentation: https://www.freebsd.org/docs/
  • OpenBSD Project – Goals & Security: https://www.openbsd.org/faq/faq4.html
  • NetBSD Project – Platform Overview: https://www.netbsd.org/ports/
  • DragonFlyBSD – HAMMER2 Documentation: https://www.dragonflybsd.org/docs/hammer2/
  • pfSense – Documentation & Release Notes: https://docs.pfsense.org/
  • OPNsense – Features & Roadmap: https://opnsense.org/
  • TrueNAS – ZFS Management: https://www.truenas.com/
  • GhostBSD – Desktop Project: https://ghostbsd.org/
  • MidnightBSD – Release Notes: https://midnightbsd.org/
  • NomadBSD – Live‑USB System: https://nomadbsd.org/
  • NetBSD – WAPBL & FFS: https://netbsd.org/docs/technical/
  • OpenBSD – pf Manual Page: https://man.openbsd.org/pf.conf
  • FreeBSD – Jails Handbook: https://docs.freebsd.org/en/books/handbook/jails/
  • DragonFlyBSD – Vkernel Overview: https://www.dragonflybsd.org/docs/vkernel/

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.