Qt Edge AI

Qt Edge AI is for applications whose logic or user interface must react to what a camera sees: the video stream is analyzed by an AI model on the device itself, and the application consumes the model's results. Integrating an on-device AI runtime normally means writing pipeline code against one vendor's stack; Qt Edge AI instead provides C++ classes and QML types that describe the inference pipeline independently of the backend that runs it.

A Qt Edge AI application declares an inference flow: a video source step that reads frames from a Qt Multimedia capture session, a vision inference step that runs a model on those frames, and a result parser step that turns the model output into data the application can consume. Steps exchange data through typed ports. Consecutive steps connect automatically when their port types match, and connections can also be declared explicitly, per port. The actual pipeline work is done by a backend loaded from a plugin, so the same application code runs on any platform that has a matching backend plugin.

Qt Edge AI is a Technical Preview and its API may change. The module ships one backend, built on GStreamer 1.20 or later, with inference step providers for the Qualcomm Intelligent Multimedia SDK and for Edge Impulse models; the provided step types cover video input, vision inference, and result parsing. Without a matching backend plugin on the target, flows cannot run.

Qt Edge AI does not capture or render video itself: Qt Multimedia owns the camera through its capture session, and Qt Edge AI reads frames from that session. Use Qt Multimedia alone to capture, play back, or display video; add Qt Edge AI when AI results computed from the video should drive the application.

Getting started

To use the QML types, add the following import statement to your .qml file:

import QtEdgeAi

To link against the C++ library, add the following to your project's CMakeLists.txt file:

find_package(Qt6 REQUIRED COMPONENTS EdgeAi)
target_link_libraries(mytarget PRIVATE Qt6::EdgeAi)

A minimal working example

The following application shows live camera video and runs an Edge Impulse model on the same frames, logging each inference result to the console:

import QtQuick
import QtMultimedia
import QtEdgeAi

Window {
    id: window
    width: 640
    height: 480
    visible: true

    Component.onCompleted: {
        session.camera.start()
        pipeline.start(window)
    }

    CaptureSession {
        id: session
        camera: Camera {}
        videoOutput: videoOutput
    }

    VideoOutput {
        id: videoOutput
        anchors.fill: parent
    }

    InferenceFlow {
        id: pipeline

        InferenceVideoSource {
            captureSession: session
        }

        VisionInference {
            name: "edgeimpulse"
            model: "libgstedgeimpulse.so"
        }

        InferenceResultParser {
            onDataAvailable: data => console.log(data)
        }
    }
}

The Simple Face Detection example walks through this application.

Explore Qt Edge AI

• Qt Edge AI Examples

Platform support and dependencies

The C++ module depends on Qt Core and Qt Multimedia; the QML types additionally use Qt Qml and Qt Quick. Inference runs through backend plugins:

The QT_INFERENCE_FLOW_BACKEND environment variable selects the backend; the default is gstreamer.

Module status and licensing

Qt Edge AI was introduced in Qt 6.13 as a Technical Preview module: the API is under development and may change in future releases.

The Qt Edge AI module is available under commercial licenses from The Qt Company. See Qt Licensing for further details.