veriCue

Commercial test automation framework for Qt desktop applications.

veriCue has two halves: the veriCue Runtime, which runs inside your Qt application and exposes its live object tree, and three client libraries (Python, C++, C#) that connect to it and drive your UI. It works equally well for QWidget and QML applications, supports touch and gestures, and includes RSA-signed commercial licensing.

The usual starting point is your own application, unmodified:

vericue run ./MyApplication        # automate it
vericue inspect ./MyApplication    # pick elements and copy their paths

On compatible configurations - dynamically linked Qt, matching Qt major, Linux x64 or Windows x64 - that needs no source change and no rebuild. Where injection is unsuitable or unsupported (macOS, a statically linked Qt), embed the Runtime instead: link vericue::vericue-server and call VeriCueServer::startLocal() or start(port), see Embedding. Either way the same Runtime code runs inside the application process; injection changes only how it gets there, and the command surface, authentication and licensing are identical.

The Runtime uses your application's Qt - veriCue does not bring a second Qt into your process. That makes Qt Core, Qt Gui and Qt Network prerequisites your deployment must provide, while Widgets and Quick support load only when your application already uses those modules: what Qt your application needs. The Inspector is a separate application and ships its own Qt for its own process, which never enters the application under test.

Clients reach it over a local IPC endpoint or TCP. Local IPC is the recommended path when the client and the application run on the same Linux or macOS machine; TCP is what you use for Windows, and for anything crossing a host, container or device boundary.

We are up front about the edges too: see the honest list of what is not supported yet.

Why veriCue

• 42 protocol commands covering object discovery, UI interaction, touch & gestures, model/view data access, push event subscription, performance metrics, and recording.
• Three first-class clients - Python (asyncio), C++ (Qt signals/slots), C# (.NET 8) - all mirroring the same surface.
• Production-grade licensing built in: RSA-signed offline keys, plans sized by concurrent automation sessions (Trial / Professional / Enterprise / Enterprise Plus - see pricing).
• Two transports, one protocol - a user-private local IPC endpoint for same-host runs on Linux and macOS, TCP for Windows and for cross-host, container and device setups. Same commands, same handshake, same licensing on both.
• No vendor lock-in - the wire protocol is documented (length-prefixed JSON, byte-identical on either transport) and you can write a client in any language.

What's next?

• Installation - get the Runtime library + a client in five minutes.
• Quick start (Python) - your first automated test in fifteen lines.
• Transports: local IPC vs TCP - which one to pick, and what each costs you.
• Commands reference - every protocol command with arguments and return shape.
• Embedding the server - what to do in your Qt application's main().

Ready to try it?

Nothing to request. The 30-day trial is keyless: download veriCue, start the embedded server without calling setLicenseFile(), and the trial begins on first run - no credit card, no sales contact. Start at vericue.dev/start or go straight to Installation.

Want a signed trial key for a longer, organization-wide evaluation, or an onboarding session? E-mail sales@vericue.dev - we respond within one business day.