Skip to content

Qt-Migration von Qt 5 auf Qt 6

Ihre Anwendung läuft auf Qt 5, und die Frage nach Qt 6 kommt inzwischen von mehreren Seiten – vom neuen SoC, vom Support-Kalender, von der Sicherheitsabteilung. Wir übernehmen diese Migration als eigenes Projekt: mit einer belastbaren Aufwandsabschätzung, bevor Sie entscheiden, und danach in Stufen, die einzeln lauffähig und testbar bleiben. Ihre Entwicklung steht dabei nicht still. Auf Embedded-Zielen decken wir zusätzlich das ab, was auf dem Desktop unsichtbar bleibt: den umgebauten Grafikstack und das BSP darunter.

Was umfasst eine Qt-Migration bei bitshift?

Wir übernehmen den Weg von Qt 5 nach Qt 6 vollständig – oder genau die Stufe, an der es gerade klemmt.

  • Aufwandsabschätzung vorab über einen zeitlich begrenzten Spike, mit konkreten Posten statt einer Pauschale
  • Modernisierung auf Qt 5.15 mit aufgeräumten Deprecation-Warnungen – die wirksamste und am häufigsten übersprungene Stufe
  • Umstellung des Builds von qmake auf CMake, als eigener, isoliert verifizierbarer Schritt
  • Wechsel auf Qt 6 mit Qt5Compat als Brücke, anschließend Ablösung der Übergangsabhängigkeiten
  • Ersetzen entfallener Bausteine – Qt Quick Controls 1, für Qt 6 neu geschriebene Module wie Qt Multimedia, QRegExp und QTextCodec
  • Grafikstack und Plattform-Plugin auf der Zielhardware verifizieren, nicht nur im Desktop-Build
  • Absicherung durch automatisierte Tests, auf Wunsch über unser Embedded Testrack auf realer Hardware

Warum steht die Migration überhaupt an?

Der Druck kommt selten aus dem Support-Kalender, sondern fast immer aus der Hardware.

Qt 5.15 war die letzte Qt-5-Version mit Langzeit-Support; der Open-Source-Support ist ausgelaufen, die kommerziellen Konditionen ändern sich über die Jahre – den aktuellen Stand klären Sie am besten direkt mit The Qt Company. Der eigentliche Auslöser ist aber meist ein neuer SoC: Er bringt eine neuere Yocto-Version mit, die einen neueren Compiler und neuere Systembibliotheken mitbringt, und irgendwann baut ein altes Qt 5 darin nicht mehr sauber. Wer bis dahin wartet, migriert unter Zeitdruck parallel zu einem Board-Bring-up. Das ist die teuerste denkbare Reihenfolge.

Wie läuft die Migration ab?

In fünf Stufen, von denen jede für sich lauffähig bleibt – der häufigste Fehler ist, Qt-Version, Build-System und Compiler gleichzeitig zu wechseln.

StufeArbeitErgebnis
1Auf Qt 5.15 gehen, Deprecation-Warnungen auflösenLaufende Anwendung ohne veraltete Aufrufe
2Build auf CMake umstellen – noch unter Qt 5Build-Wechsel isoliert verifiziert
3Wechsel auf Qt 6 mit Qt5Compat als BrückeErste lauffähige Qt-6-Version
4Qt5Compat ablösen, QML auf versionslose ImporteKeine Übergangsabhängigkeiten mehr
5Grafikstack und Plattform-Plugin auf dem Ziel prüfenBestätigtes Verhalten auf dem realen Gerät

Weil nach jeder Stufe ein funktionierender Stand existiert, hat ein auftretender Fehler jeweils nur eine plausible Ursache. Die technischen Hintergründe dazu haben wir ausführlich in unserem Artikel Von Qt 5 auf Qt 6 migrieren beschrieben.

Was ist auf Embedded-Zielen zusätzlich zu tun?

Auf dem Desktop endet eine Migration beim grünen Build. Auf dem Gerät fängt die eigentliche Prüfung dort erst an.

Qt Quick rendert in Qt 6 nicht mehr direkt gegen OpenGL, sondern über die RHI – eine Abstraktion über die Grafik-API der jeweiligen Plattform. Auf dem Desktop merkt man davon wenig. Auf einem Board mit EGLFS, einem herstellerspezifischen EGL und einem GPU-Treiber, dessen Eigenheiten das Team über Jahre gelernt hat, kostet genau das Zeit. Dazu kommt das BSP: Die Qt-6-Schicht muss zur Yocto-Version des Boards passen, und ein Sprung über mehrere Yocto-Releases zieht Kernel, Toolchain und Systembibliotheken mit. Wie wir solche Layer bauen und pflegen, steht unter Yocto BSP & Distributionen.

Der Unterschied zu einer reinen Qt-Werkstatt: Weil wir die Embedded-Linux-Plattform darunter ohnehin beherrschen, ist die BSP-Frage für uns Teil des Auftrags und keine Schnittstelle, an der die Zuständigkeit endet.

Was kostet eine Qt-Migration?

Eine belastbare Zahl entsteht erst nach dem Spike – vorher wäre sie geraten.

Vier Fragen bestimmen den Aufwand: Wie viel QML gibt es, und hängt es an Qt Quick Controls 1? Nutzt die Anwendung Module, die für Qt 6 neu geschrieben wurden – Qt Multimedia vor allem? Wie eigenwillig ist der Grafikstack der Zielhardware? Und existieren automatisierte Tests, die eine Regression überhaupt sichtbar machen würden? Wir klären das in einem überschaubar bemessenen ersten Schritt und legen Ihnen danach eine Abschätzung mit benannten Posten vor. Sie entscheiden auf dieser Grundlage, ob und in welchem Umfang es weitergeht.

Warum bitshift dynamics für Ihre Qt-Migration?

Weil bei uns Qt-Kenntnis und Embedded-Tiefe aus demselben Team kommen.

Wir arbeiten seit 2005 an hardwarenaher Software und decken C++, Qt/QML, Embedded Linux und Yocto gemeinsam ab – deshalb bleibt eine Migration bei uns nicht am Grafikstack oder am BSP hängen. Wir sitzen in Lörrach im Dreiländereck, arbeiten remote-first und bei Bedarf vor Ort im DACH-Raum, auf Deutsch und auf Englisch. Wenn Ihr Team die Migration selbst durchführen möchte, geht das ebenso: Dann begleiten wir sie als Sparringspartner oder über eine passende Schulung.

Häufige Fragen

Woher wissen wir vorab, wie aufwändig unsere Migration wird?
Aus einem zeitlich begrenzten Spike, nicht aus einer Zeilenzählung. Wir setzen die ersten Stufen auf einem Branch um – Modernisierung auf Qt 5.15 und die Umstellung des Builds – und bringen die Anwendung gerade so weit, dass sie unter Qt 6 startet. Danach ist der Rest benennbar: Wie viel QML gibt es, hängt die Oberfläche an Qt Quick Controls 1, sind für Qt 6 neu geschriebene Module wie Qt Multimedia im Spiel, und wie eigenwillig ist der Grafikstack der Zielhardware. Sie bekommen eine Abschätzung mit konkreten Posten statt einer Hausnummer.
Können wir während der Migration weiter am Produkt arbeiten?
Ja, und genau darauf ist das stufenweise Vorgehen ausgelegt. Jede Stufe endet mit einer lauffähigen Anwendung, deshalb bleibt der Hauptzweig die ganze Zeit über auslieferbar. Die aufwändigste Stufe – die Modernisierung auf Qt 5.15 mit aufgeräumten Deprecation-Warnungen – findet noch vollständig unter Qt 5 statt und lässt sich als normale Weiterentwicklung integrieren.
Müssen wir dabei zwingend von qmake auf CMake wechseln?
Anwendungen lassen sich weiterhin mit qmake übersetzen. Qt 6 selbst wird jedoch mit CMake gebaut, und Dokumentation, Werkzeuge und Beispiele sind darauf ausgelegt – jede Erweiterung führt früher oder später dorthin zurück. Wenn ohnehin migriert wird, ist der Build-Wechsel in derselben Runde die günstigste Variante. Wir machen ihn als eigene Stufe, noch unter Qt 5, damit ein Fehler danach nur eine Ursache haben kann.
Was ist bei Embedded-Geräten anders als auf dem Desktop?
Der Grafikstack und das BSP. Qt Quick rendert in Qt 6 über die RHI-Abstraktion statt direkt gegen OpenGL – Annahmen über EGL, Treiber und Plattform-Plugin müssen also neu geprüft werden. Dazu kommt, dass die Qt-6-Schicht zur Yocto-Version des Boards passen muss. Wir führen Qt-Migration und BSP-Aktualisierung bewusst als zwei getrennt verifizierte Schritte aus; das wirkt nach mehr Arbeit und ist in der Praxis deutlich billiger.
Wir haben eine geerbte Qt-Anwendung ohne Tests. Geht das trotzdem?
Ja, das ist eher der Regelfall als die Ausnahme. Eine Migration ändert an tausend Stellen sehr wenig und an wenigen Stellen sehr viel – ohne Tests bleibt offen, welchen der beiden Fälle man gerade getroffen hat. Wir bauen deshalb zu Beginn eine schmale Absicherung für die kritischen Pfade auf. Auf realer Hardware übernimmt das unser Embedded Testrack, sodass eine Regression im Grafik- oder Eingabepfad sofort auffällt statt beim Kunden.
Übernehmen Sie auch eine Migration, die bereits feststeckt?
Ja. Ein häufiges Muster ist, dass Qt-Version, Build-System und Compiler gleichzeitig gewechselt wurden und es nun keinen lauffähigen Zwischenstand mehr gibt. Wir stellen in solchen Fällen zuerst einen definierten Ausgangspunkt her und ordnen die Arbeit anschließend in die Stufenfolge ein, statt den angefangenen Umbau weiter vor sich herzuschieben.

Fachartikel zum Thema

Wie wir arbeiten und worauf es in der Praxis ankommt – aus unserem Blog.

· 6 Min. Lesezeit

Qt im Embedded-Umfeld

Wie Qt moderne Bedienoberflächen auf ressourcenbeschränkte Hardware bringt – von QML und Hardwarebeschleunigung bis zu Boot-Zeit und schlankem Stack.

  • Qt
  • QML
  • Embedded Linux
Weiterlesen
· 8 Min. Lesezeit

Modernes C++ (17/20/23) für Embedded-Systeme

Wie C++17, C++20 und C++23 Embedded-Software sicherer und klarer machen – bei kaum Laufzeitkosten, diszipliniert eingesetzt auf beschränkten Zielen.

  • C++
  • Modern C++
  • Embedded
Weiterlesen

Passende Leistungen

Lassen Sie uns über Ihr Projekt sprechen

Ob neue Produktentwicklung, Modernisierung einer bestehenden Anwendung oder ein Engpass im Team – wir freuen uns auf Ihre Nachricht.

Projekt anfragen