Software Insights

Architecture as Code: A Developer-Friendly Approach to Architecture Verification

Prof. Dr. Rainer Koschke — Tue, 21 Apr 2026 11:49:01 GMT

7 Years of HMIs: Here’s What I Noticed About UX/UI Best Practices.

Shawn Dorsey — Wed, 08 Apr 2026 08:11:23 GMT

Let me set the scene.

The Conversation We’re Having at Auto China 2026

Annika Packalén — Tue, 07 Apr 2026 11:37:15 GMT

Qt Group is coming to Auto China 2026. Here's what's on our mind, and on the show floor.

From CPU to GPU: A Safe and Structured Migration Approach Using Architecture Verification

Dr. Daniel Simon — Thu, 19 Mar 2026 15:34:09 GMT

The availability of high-performance GPUs that drastically speed up computations in many different domains gives a new push to the idea of migrating legacy systems’ CPU algorithms to their GPU counterparts to benefit from the speedups. Migrating existing CPU-based C/C++ code to GPU-accelerated implementations (CUDA® or similar models) is not primarily a syntactic transformation. It is an architectural intervention. Not limited to safety-regulated systems, e.g. in medical devices or automotive, the challenge is not only about rewriting functions but also about preserving system integrity while introducing a fundamentally different execution model.

A disciplined approach is required to control risk, maintain correctness, and ensure long-term maintainability. This post outlines a method that combines architectural analysis with continuous verification and CUDA-specific safety enforcement.

Sneak Peek: Qt Robotics Framework (Proof-of-Concept)

Qt Group — Thu, 19 Mar 2026 11:54:03 GMT

Industry Insights Blog Series

A Perfect Engineering Partnership: Refactoring and Architecture Verification

Julia Probst — Wed, 18 Mar 2026 10:56:59 GMT

What Is Code Refactoring?

Refactoring reshapes code to make future work easier

At its core, refactoring focuses on restructuring code to improve its clarity, design, and maintainability while preserving all functional outcomes, e.g., better naming, cleaner abstractions, fewer duplicates, and more transparent data flow. The aim is to create a codebase where adding features or fixing defects becomes faster and less risky.

RAM in Embedded Systems: How to Protect Margins in the Memory Crunch

Fabrizio Trotti — Fri, 06 Mar 2026 05:55:19 GMT

Memory prices are keeping R&D managers and CTOs awake at night, and for good reason. Between Q4 2025 and Q1 2026, conventional DRAM contract prices surged by more than 100%. For companies shipping connected devices at scale, that isn't an engineering footnote. It's a direct hit to the bottom line.

UI Animation Types in QML And When To Use Them

Peter Rohles — Wed, 04 Mar 2026 08:42:31 GMT

I wanted to write a blog post about UI animation types in QML for a while, and as I prepared to do that, I noticed that my last (and first) post about atomic design systems was a big hit. Here’s the first comment.

Only because you can produce these walls of AI generated marketing material doesn't mean you should. This is getting ridiculous.

Nice. So, to sound more human than a human can be, I’ll be a little more unhinged while writing about animated UIs. Little proof-reading, minimal formatting, and I might even use some profanity. Let’s see if marketing approves that.

Why UI Animations Matter

Animations are not rooted in the design of user interfaces, yet they have played a crucial role in human-machine interactions for years already. The Interaction Design Foundation says that “they contribute significantly to the functionality of appeal of user interfaces”, and that “designers use animations to highlight changes, guide tasks, provide feedback, and add a layer of polish to a design”.

Even when considering designing for embedded devices, such as a car infotainment system or a display that controls a washing machine, UI animations go beyond the visual appeal.

And as technology advances and hardware (both MPUs and MCUs) gets more performant, motion design becomes increasingly easier to implement. Digital touch-screens now often transition with slides, progress bars might show movements inside of the filled-in area, animations might accompany a loading screen. Animating the UI on an embedded device is now a way to signal something relevant to the user while keeping them engaged in an interaction that increasingly resembles the one they have with their smartphones.

Two Ways To Think About UI Animation: Motion Graphics and Interactions

I have been thinking about animations in two broad categories: motion graphics and interactions. You can see them both in action in our car HVAC system demo here.

I am not saying this is the only way to categorize them; there are plenty of other ways to do that. You could look at their function (e.g., loading, progression, transition animations), or their format (Lottie, SVG, .mov), but I’d rather focus on the style of interaction.

Motion Graphics

Motion graphics are animations that play on their own, no user trigger required. This could be a loading spinner, a pulsing indicator, an ambient movement in the background, or even blades of grass swaying in the wind in a video game. Yeah, that last one was pretty specific. These types of animations are often looped or driven by timers and can sometimes be called non-real-time animations.

Motion graphics are animations that play on their own, as in the example with Duolingo's Duo (source: Verge)

Interactions

Interactions are animations triggered by user events. This could be a button press, a hover, a menu sliding, cards flipping over, or toggle switches snapping on and off. These animations provide feedback on the user input and make UIs feel more responsive. They are also called real-time animations.

Interactions are triggered by user events, as in the example of the button with a hover state that appears when a user places her cursor over the button (source: NNG Group)

How QML is Related to UI Animation

If you’re new here, QML is Qt’s declarative language for building user interfaces, and animation is a fundamental part of QML and the UIs you can create with it.

In QML, animations are applied to property changes. An animation defines the interpolation curve from one value to another when a property value changes. These animation curves create smooth transitions from one value to another.

An animation is defined by a series of target properties to be animated, an easing curve for the interpolation curve, and a duration. All animations in Qt Quick are controlled by the same timer and are therefore synchronized. This improves the performance and visual quality of animations.

There are plenty of UI animations in QML, and you can find them all described in our documentation. For the purpose of this article, I want to give an overview of the most common ones.

QML UI Animation Types

The base class for all animations in QML is Animation. Everything below inherits from it, which means all the common properties of Animation (running, loops, paused, etc) are available on every animation type.

I’ve organized the animation types in QML by what they do rather than their inheritance tree.

Property Animations

Property animations interpolate a property from one value to another over a duration.

PropertyAnimation - This is the general-purpose one. Animates any property that holds a numeric, color, vector, or other interpolatable value. You specify from, to, duration, and optionally easing.type.
NumberAnimation - A convenient subtype of PropertyAnimation. Functionally identical to PropertyAnimation but explicitly for numbers.
ColorAnimation - It interpolates between colors.
RotationAnimation - This is a rotation with control over direction (clockwise, counterclockwise, shortest path).
Vector3dAnimation - This defines an animation to be applied when a Vector3d value changes, and it can be applied in a number of ways (transitions, behaviors, property value sources).
SmoothedAnimation - It animates a property toward a target value. Instead of specifying duration, you specify velocity. Great for tracking a moving target smoothly (like a cursor).
SpringAnimation - This is a physics-based spring animation. You configure spring, damping, and mass, and the animation oscillates and settles like a real spring. Excellent for natural-feeling interactions like pull-to-refresh.

An example of a spring animation in QML. Spring animation is excellent for natural-feeling interactions, such as pull-to-refresh.

Group Animations

Group animations handle multiple animations.

ParallelAnimation - It runs multiple animations at the same time (fade in while sliding up).
SequentialAnimation - This runs animations one after another. Use for multi-step (slide in, then fade up).
PauseAnimation - This animation inserts a delay inside a sequentialAnimation. Just a duration - no property changes.

Structural Animations

Structural animations depict changes in an object's structure.

AnchorAnimation - This allows animation changes to anchor-based layouts. When you change which anchors an item uses (anchored left to right) this interpolates the position change.
ParentAnimation - It animates reparenting. When an item’s parent changes, this ensures the visual position changes smoothly.
PathAnimation - An animation that moves an item along a path.

An example of a parent animation in QML, ensuring that the visual position changes smoothly when the item's parent changes.

Utility Animations

ScriptAction - It runs a Javascript snippet. Useful for triggering effects during an animation.
PropertyAction - It instantly sets a property value at a specific point in an animation. Useful inside SequentialAnimation when you need to snap a property to a value between animated steps.

Animator

This is a special type. Unlike standard animation types that run on the GUI thread, this runs on the render thread. This means it can stay smooth even when the GUI is busy. The trade-off is that it is limited to a few properties (x, y, opacity, rotation, scale).

Behavior

Behavior isn’t exactly an animation type, but it’s a way to attach animations directly to a property so it runs automatically whenever that property changes.

Rectangle{
  width: 100
  Behavior on width {
    NumberAnimation { duration: 1000}
  }
}

This inline NumberAnimation runs whenever the width value changes.

When to Use Transitions or Timelines

Transitions and timelines are not competing tools; they solve different problems, and most real-world QML projects end up using both.

Transition

Transitions are state-driven. They are tightly integrated with the State system. They fire automatically when states change, for example, when the user clicks a button or completes a given action. You define states, and a transition describes how to animate between them.

Transitions should be your default when you are dealing with state-driven UI animations.

In the screenshot, see how transitions are used in Qt Design Studio to create UI animations.

Timeline

Timeline is a keyframe-based animation system that gives you precise control over property values at specific points in time or at particular frames. This is ideal for complex animations, and you can drive the currentFrame property by anything, like a slider. Timeline is a great way to create interactive animations in Qt Design Studio visual editor. As it is not integrated with the State/Transition system, you have to wire up state-driven behavior manually with Timelines.

While it can be an overkill for simple property animations, timelines are best for complex, multi-property animations, and you should use Timeline when you need key framing or want animations driven by something other than states.

A screenshot showing how animations are used in Qt Design Studio to create UI animations.

In Conclusion!

UI animations are not an afterthought; they are a core part of what makes an interface feel alive. Whether you’re building a modern home appliance display or a safety-critical user interface for a medical device, the distinction between motion graphics and interactions should guide most of your decisions. If something plays on its own to communicate progress or keep the user engaged, motion graphics and Timeline are the way to go. On the other hand, if something responds to a user action, lean into interactions and transitions.

You can, of course, mix the two when it makes sense, because real UIs (and real use cases) rarely fit a single pattern. The goal should always be the same: make the user interface feel like it’s responding to the person using it, not just a showcase of infinite possibilities.

The ROI of Stability: How High‑Performing Teams Expand Beyond OSS Tools

Karim Boussema — Tue, 17 Feb 2026 10:00:00 GMT

The insights in this guide come fromKarim Boussema, Solutions Engineer at Qt Group.. Through his experience across desktop, web, mobile, and embedded projects, Karim has seen consistent patterns where open‑source GUI testing tools succeed, where they struggle, and when teams recognize it’s time to evolve.

His practical observations form the foundation of this blog: a clear, experience‑based look at the real pain points, scaling challenges, and transition paths teams encounter when moving beyond open‑source tooling toward more sustainable GUI testing practices.

When do you Start Outgrowing Your OSS Testing Stack?

For many teams, the idea of switching from open-source testing tools to a commercial solution feels daunting. There’s a sense of loyalty to the tools they’ve built around, the scripts they’ve maintained, and the workflows they’ve optimized over time.

And there’s the ever-present question: “Is it really worth paying for something we already do for free?”

But here’s the truth: free isn’t always free.

The cost of maintaining brittle selectors, debugging flaky tests, and manually triaging regressions adds up. Quietly, invisibly, and relentlessly. And when those tests fail to catch a critical bug before release, the cost becomes very visible.

So how do you Begin the Transition without Disrupting Everything?

Step 1: Acknowledge the Pain Points

Begin with an open, fact-based discussion within your team. What is working well? Where are the biggest inefficiencies? Are your tests providing real confidence in product quality, or are they fragile and prone to false positives?

Common indicators include:

Tests that break with every UI change
Extended triage cycles — significant time spent analyzing test failures to determine whether they are genuine defects, flaky tests, or environment issues
Manual testing bottlenecks
Challenges in automating consistently across platforms (desktop, embedded, web)
Limited traceability or audit readiness

These are your signals. Recognizing them is the first step toward evolving your testing strategy.

Step 2: Use a Structured Evaluation Framework

Don’t jump into a full migration. Instead, use a framework like WSJF (Weighted Shortest Job First) to prioritize where automation will have the biggest impact.

WSJF (Weighted Shortest Job First) is a prioritization method used in Agile frameworks, especially SAFe (Scaled Agile Framework), to decide which work items (features, epics, jobs) should be done first in order to deliver the maximum economic benefit.

WSJF = (Business Value + Risk Reduction + Defect Frequency + Cycle-Time Impact) / Effort

Start with:

High-risk, high-frequency GUI flows
Manual tests that are repetitive and error-prone
Areas with the most flakiness or maintenance overhead

This helps you focus on value, not just volume.

Step 3: Run a Pilot, Not a Revolution

Choose 15–20 critical test cases. Run them in parallel using a commercial test automation tool and your current tool. Compare:

Flakiness
First-pass success rate
Time to triage
Developer/tester feedback

This phase is about demonstrating how a new tool integrates into yourreal workflow. Let developers store tests in Git, run them locally and in CI, and use a centralized test management system to keep results visible and consistent.

Use the Automation & Testing Strategy Canvas to guide your pilot

To ensure your pilot is structured, rather than a loose experiment, useThe Automation & Testing Strategy Canvas, a visual framework designed to bring clarity and focus to automation efforts. The canvas providesten guided sectionsthat help teams evaluate people, processes, tooling, quality, and speed, offering a shared language to understand current maturity and priorities. It also enablesdata‑driven self‑assessment, allowing teams to score where they stand today and identify gaps before expanding automation further.

Teams use the canvas to:

Map out their automation context and goals
Highlight strengths, bottlenecks, and improvement areas
Align stakeholders before making tool decisions
Turn pilot findings into a simple, actionable roadmap

Start planning a workshop with your team

Step 4: Empower Champions and Train Smart

Identify one or two team members to act as champions: individuals who are curious, collaborative, and open to learning. Provide them with concise, role-specific training and opportunities to gain practical experience by shadowing others or pairing with developers and manual testers.

For the broader team, focus on clarity and accessibility. Instead of extensive documentation, begin with quick reference guides, practical examples, and short, hands-on sessions. The objective is to build confidence and capability without adding unnecessary complexity.

Step 5: Migrate Gradually, Not Line-by-Line

You don’t need to rewrite every test. Instead:

Migrate scenarios, not scripts
Archive or deprecate legacy tests that no longer add value
Use Squish’s object maps and stable locators to reduce maintenance
Move trivial GUI checks to API tests where possible

Keep the old system running for 1–2 sprints, then sunset it. This avoids double maintenance and builds trust in the new stack.

Step 6: Measure and Communicate Impact

Build a before/after TCO model to show leadership how much time, effort, and risk you’ve reduced. Frame it in terms of confidence gained, not just bugs caught.

Track KPIs like:

Flakiness rate
First-pass green rate
Mean time to triage
Escaped defects
Cost per passing test

How to Balance Open-Source and Commercial Testing Tools

Open-source frameworks such as Selenium, Playwright, or custom wrappers are widely used and often deliver good value, especially for straightforward web or application testing. They can be effective starting points. But as projects grow in scale or complexity, their limitations tend to surface.

Common Challenges with Open-Source Tools:

Flaky tests: Reliance on image recognition or coordinate-based clicks makes tests brittle as UIs evolve.
High maintenance overhead: Teams may spend more time fixing broken tests than creating new coverage.
Fragmented workflows: CI/CD integration is inconsistent, particularly when multiple platforms are involved.
Limited embedded support: Most OSS tools are not designed to reliably test microcontrollers or embedded targets.
Lack of audit trail: In regulated industries, the absence of traceability and reporting creates compliance gaps.

These challenges don’t mean open source is the wrong choice. Rather, they highlight where it reaches its limits.

The reality is that most organizations benefit from a hybrid approach, retaining OSS where it works best and introducing commercial tools where they add clear value.

How to Build a Hybrid Testing Stack: Moving from Fragmented Effort to Unified Confidence

The journey from open-source testing to more advanced approaches is not about abandoning what already works. Instead, it is about evolving toward practices that can scale. By aligning tooling decisions with the complexity of your product and the maturity of your processes, you avoid the trap of over-investing in maintenance while ensuring that quality, compliance, and efficiency keep pace with business needs.

When to Expand with Commercial Tools:

OSS tests remain flaky or consume excessive maintenance time
Your testing scope includes desktop, embedded, or Qt-based applications
Compliance, SLAs, or audit readiness are business requirements

When to Retain OSS:

Test flows are low-risk, stable, and inexpensive to maintain
Open-source frameworks integrate more seamlessly with niche or specialized systems

In both situations, the shift is not only technical but also cultural. It involves moving from reactive testing toward proactive quality assurance. It also means progressing from uncertainty to confidence and from scattered efforts to a unified strategy.

What Defines a Successful Transition

To ensure a smooth transition, the team that success follow the following steps:

They begin with shortlisting solutions for small pilots, measuring results, and scaling thoughtfully.
They empower champions, invest in targeted training, and build team-wide buy-in.
They retain what continues to work, such as OSS tools for niche flows or manual testing for edge cases, while introducing new solutions that enable growth.

Ultimately, these teams transform QA from a cost center into a cornerstone of product excellence. The path forward is clear: start small, measure what matters, and evolve with purpose.

The key insight

Move beyond "free versus paid" thinking to evaluate total value: team productivity, product quality, risk reduction, and long-term maintainability.

Start with focused pilots on your most challenging scenarios. Real implementation data will guide decisions better than theoretical comparisons.The question isn't whether commercial tools are universally worth the investment. It's whether they're worth it for your specific situation, team capabilities, and strategic goals.

Audit your current testing pain points: Document time spent on maintenance, test reliability issues, and coverage gaps

Identify your highest-priority testing challenges: Use the prioritization formula above

Build the shortlist of top tools and request focused demonstrations: Ask vendors to show solutions for your specific problems, not general feature tours

Run targeted pilots with free evaluation licenses or trials: Test the tools on your most challenging scenarios first before committing to a commercial investment

Gather feedback from your team: Collect input from both testers and developers after the pilot

Measure results objectively: Track test reliability, maintenance time, and team productivity

Ready to explore your options? Begin with an honest assessment of your current testing challenges, then evaluate solutions based on their ability to solve your specific problems rather than their price tags.

How to Get Started with Automated Testing Handbook will help you to get started. It is a 5-step journey to implementing automated testing for your applications.

When organizations evaluate test automation solutions for their applications, they often focus on creating a comprehensive implementation plan that describes their goals and strategy for successfully adopting automated testing.

Implementation teams define objectives for each phase from initial assessment to full-scale automation deployment. However, we have seen too many automation projects fizzle out. Why? Because success is not just “have tests that run automatically.” True success means:

Measurable impact — you can see how much time, bugs, or risk you’ve eliminated
Sustained adoption — the team trusts and maintains the tests
Scalability — your framework grows with new features and platforms
Integration with development flow — tests run as part of CI, not as an
afterthought

GUI for Embedded Applications: Expert Design Insights & Trends

Fabrizio Trotti — Fri, 09 Jan 2026 06:45:00 GMT

Modern embedded devices are ubiquitous, found in a wide range of applications, including medical equipment, automotive dashboards, and industrial control systems. Yet creating an effective GUI for embedded applications remains one of the most challenging aspects of product development. We recently hosted a webinar featuring four industry veterans with over 60 years of combined experience to discuss the realities of embedded GUI design, what's working, what's still broken, and where the field is headed.

Our panel included:
• Shawn Dorsey - Senior Manager of UI/UX at Qt
• Jason Manns - Senior Technical Artist at Qt
• Dennis Lenard - Founder and Managing Director at Creative Navy
• Sven Heller - CEO at Create Next

Here's what they had to say about the evolution, challenges, and future of GUI design for embedded systems.