> ## Documentation Index
> Fetch the complete documentation index at: https://dragonwingdocs.qualcomm.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Robotics developer workflow

> Unified workflow for the QIR SDK across Qualcomm Linux and Ubuntu on Qualcomm Dragonwing kits.

export const WorkflowNavigator = () => {
  const workflows = {
    evaluate: {
      title: "Evaluate scenario",
      href: "/scenarios#evaluate",
      description: "Assess platform capability with a prebuilt image and stock sample applications."
    },
    development: {
      title: "Development scenario",
      href: "/scenarios#development",
      description: "Learn the QIR SDK, cross-compile a ROS 2 sample, and deploy it to the device."
    },
    production: {
      title: "Production scenario",
      href: "/scenarios#production",
      description: "Pin QRB ROS packages per technology area (Vision, Multimedia, AI inference and Zero-copy, Tooling) and build a repeatable image or Debian package for release."
    }
  };
  const deviceOsSupport = {
    "IQ-9075 EVK": ["Qualcomm Linux", "Ubuntu"],
    "IQ-8275 EVK": ["Qualcomm Linux"],
    "Ventuno Q": ["Ubuntu"]
  };
  const [device, setDevice] = useState("IQ-9075 EVK");
  const [os, setOs] = useState("Ubuntu");
  const [scenario, setScenario] = useState("evaluate");
  const result = workflows[scenario];
  const supportedOs = deviceOsSupport[device];
  const handleDeviceChange = selectedDevice => {
    setDevice(selectedDevice);
    if (!deviceOsSupport[selectedDevice].includes(os)) {
      setOs(deviceOsSupport[selectedDevice][0]);
    }
  };
  const rowStyle = {
    display: "block",
    margin: "0 0 8px 0",
    lineHeight: "1.5"
  };
  return <div className="p-4 border dark:border-zinc-950/80 rounded-xl not-prose">
      <div className="space-y-4">
        <div>
          <h3 className="text-base font-semibold mb-2">Step 1. Choose your device</h3>
          <div style={{
    display: "flex",
    gap: "8px",
    flexWrap: "wrap"
  }}>
            {Object.keys(deviceOsSupport).map(item => <button type="button" key={item} onClick={() => handleDeviceChange(item)} aria-pressed={device === item} style={{
    padding: "10px 16px",
    borderRadius: "8px",
    border: device === item ? "2px solid #31017D" : "1px solid #ccc",
    background: device === item ? "#31017D" : "white",
    color: device === item ? "white" : "black",
    cursor: "pointer"
  }}>
                {item}
              </button>)}
          </div>
        </div>

        <div>
          <h3 className="text-base font-semibold mb-2">Step 2. Choose your operating system</h3>
          <div style={{
    display: "flex",
    gap: "8px",
    flexWrap: "wrap"
  }}>
            {["Qualcomm Linux", "Ubuntu"].map(item => {
    const isSupported = supportedOs.includes(item);
    return <button type="button" key={item} disabled={!isSupported} onClick={() => setOs(item)} aria-pressed={os === item} style={{
      padding: "10px 16px",
      borderRadius: "8px",
      border: os === item ? "2px solid #0A7C42" : "1px solid #ccc",
      background: os === item ? "#0A7C42" : "white",
      color: os === item ? "white" : "black",
      opacity: isSupported ? 1 : 0.4,
      cursor: isSupported ? "pointer" : "not-allowed"
    }}>
                  {item}
                </button>;
  })}
          </div>
        </div>

        <div>
          <h3 className="text-base font-semibold mb-2">Step 3. Choose your scenario</h3>
          <div style={{
    display: "flex",
    gap: "8px",
    flexWrap: "wrap"
  }}>
            {[["evaluate", "Evaluate"], ["development", "Development"], ["production", "Production"]].map(([id, label]) => <button type="button" key={id} onClick={() => setScenario(id)} aria-pressed={scenario === id} style={{
    padding: "10px 16px",
    borderRadius: "8px",
    border: scenario === id ? "2px solid #666" : "1px solid #ccc",
    background: scenario === id ? "#eeeeee" : "white",
    color: "black",
    cursor: "pointer"
  }}>
                {label}
              </button>)}
          </div>
        </div>

        <div style={{
    marginTop: "8px",
    border: "1px solid #ddd",
    borderRadius: "12px",
    padding: "20px"
  }}>
          <h3 className="text-base font-semibold" style={{
    marginBottom: "12px",
    display: "block"
  }}>
            Recommended path
          </h3>
          <div style={rowStyle}>
            <strong>Device:</strong> {device}
          </div>
          <div style={rowStyle}>
            <strong>Operating system:</strong> {os}
          </div>
          <div style={rowStyle}>
            <strong>Scenario:</strong> {result.title}
          </div>
          <div style={{
    ...rowStyle,
    margin: "0 0 12px 0"
  }}>{result.description}</div>
          <div style={{
    display: "block",
    marginTop: "8px"
  }}>
            <a href={result.href}>Open the {result.title} on the Scenarios page →</a>
          </div>
        </div>
      </div>
    </div>;
};

export const props_0 = undefined

The Qualcomm® Intelligent Robotics (QIR) SDK provides ROS 2 packages, a cross-compile toolchain, prebuilt images, and end-to-end samples for building robotics applications on Qualcomm Dragonwing™ platforms and Arduino® VENTUNO™ Q. The workflow is unified across every device, operating system, and scenario.

## QIR SDK components

The QIR SDK has the following components that help you build, run, and update robotics applications on Qualcomm Dragonwing hardware.

* ROS 2 Jazzy packages tuned for Qualcomm Dragonwing hardware.
* Prebuilt Qualcomm Linux robotics images (`qcom-robotics-image`, `qcom-robotics-proprietary-image`) and Ubuntu `apt` packages (`qirp-sdk`, `qirp-sdk-desktop`).
* Cross-compile toolchain for building applications on the host and deploying them to the device.
* End-to-end sample applications for platform, robotics, and AI vision use cases.
* Qualcomm Linux overlays (optional) that expand a base robotics image into the full Qualcomm proprietary stack without reflashing.

To get started with developing robotics applications, do the following:

<Steps>
  <Step title="Learn the supported devices, operating systems and scenarios.">
    First, understand the following information:

    <Columns cols={2}>
      <Card
        title="Supported OS-device matrix"
        href="#supported-os-device-matrix"
        icon={ <svg
xmlns="http://www.w3.org/2000/svg"
width={24}
height={24}
fill="none"
stroke="darkblue"
strokeLinecap="round"
strokeLinejoin="round"
strokeWidth={2}
className="lucide lucide-circuit-board preview-icon"
{...props_0}
>
<rect width={18} height={18} x={3} y={3} rx={2} />
<path d="M11 9h4a2 2 0 0 0 2-2V3" />
<circle cx={9} cy={9} r={2} />
<path d="M7 21v-4a2 2 0 0 1 2-2h4" />
<circle cx={15} cy={15} r={2} />
</svg>}
      >
        What OS the QIR SDK supports for each device.
      </Card>

      <Card title="On-device operating system" href="#on-device-operating-system" icon="square-terminal">
        Differences between Qualcomm Linux and Ubuntu OS when using the robotics workflow.
      </Card>

      <Card title="Robotics working scenarios" href="#robotics-working-scenarios" icon="picture-in-picture">
        What you can do in three main scenarios.
      </Card>
    </Columns>
  </Step>

  <Step title="Pick your combination.">
    Review the [Workflow decision tree](#robotics-workflow-decision-tree) and pick a combination using the [Workflow picker](#pick-your-combination).
  </Step>

  <Step title="Go through the tutorial for the scenario combination you choose.">
    Follow the matching tab on the [Scenarios](./scenarios) page, based on your choice.
  </Step>

  <Step title="Check end-to-end samples." />
</Steps>

## Supported OS-device matrix

The QIR SDK targets three platforms for robotics application development. Each device differs in compute class, camera and sensor ports, and OS support. The following table lists the device and operating system combinations covered by the unified robotics workflow.

| Device                                      | Target use                                                       | Qualcomm Linux | Ubuntu |
| :------------------------------------------ | :--------------------------------------------------------------- | :------------: | :----: |
| Qualcomm Dragonwing™ IQ-9075 Evaluation Kit | High-compute AI and multi-camera robotics                        |       Yes      |   Yes  |
| Qualcomm Dragonwing™ IQ-8275 Evaluation Kit | Mid-tier robotics with the Qualcomm proprietary multimedia stack |       Yes      |   No   |
| Arduino® VENTUNO™ Q                         | Development board with dual-brain architecture                   |       No       |   Yes  |

Match a device to your project priority:

* **IQ-9075 EVK** — the widest sample coverage, including every AI sample, all robotics simulations, and multi-camera pipelines on either OS.
* **IQ-8275 EVK** — the Qualcomm proprietary multimedia stack (`qrb_ros_camera`, `qrb_ros_video`, `qrb_ros_audio_service`, `qrb_ros_colorspace_convert`) on Qualcomm Linux.
* **VENTUNO™ Q** — a lower-cost board that can be used as a Single-board Computer (SBC).

## On-device operating system

The QIR SDK ships in two flavors that share ROS 2 Jazzy and most sample sources but differ in packaging, image build, and update model.

The following table lists and compares the features supported by each host.

| Property          | Qualcomm Linux                                 | Ubuntu                                                               |
| :---------------- | :--------------------------------------------- | :------------------------------------------------------------------- |
| Base distribution | Yocto-based `qcom-robotics-ros2-jazzy`         | Ubuntu 24.04 (Server or Desktop)                                     |
| Install model     | Flash a prebuilt image with `qdl`              | Flash Ubuntu, then `sudo apt install qirp-sdk`                       |
| Package source    | CodeLinaro prebuilt zips or a KAS/Yocto build  | Qualcomm Personal Package Archive (PPA) (`ppa:ubuntu-qcom-iot/qirp`) |
| Supported devices | IQ-9075 EVK, IQ-8275 EVK                       | IQ-9075 EVK, Arduino VENTUNO Q                                       |
| Proprietary stack | `qcom-robotics-proprietary-image`              | `qirp-sdk` (Server) or `qirp-sdk-desktop` (Desktop)                  |
| Overlay support   | Yes — expand Config #1 into Config #2 with DNF | Not applicable — PPA covers the proprietary stack                    |
| ROS 2 middleware  | ROS 2 Jazzy                                    | ROS 2 Jazzy                                                          |

* Pick Qualcomm Linux when you plan to customize the OS or ship a hardened Yocto image.

* Pick Ubuntu when you want a Debian-based experience with `apt`-managed updates and no Yocto.

<Note>
  The following table maps the Ubuntu image variant to the correct QIR SDK package. Installing the wrong package causes runtime errors.

  | Ubuntu variant | QIR SDK package    | Notes                                                                                                                                                        |
  | :------------- | :----------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------- |
  | Server         | `qirp-sdk`         | Includes color-space conversion and full GPU acceleration for `qrb_ros_nn_inference`.                                                                        |
  | Desktop        | `qirp-sdk-desktop` | Excludes `ros-jazzy-qrb-ros-colorspace-convert` and `ros-jazzy-qrb-colorspace-convert-lib`; skips GPU acceleration for the neural-network interface manager. |
</Note>

## Robotics working scenarios

The QIR SDK supports three scenarios, from a short evaluation to a full production build.

The following table compares the scope, output, and time investment among the three scenarios.

| Scenario    | Goal                                               | Typical output                                                                                           | Time to first result                   |
| :---------- | :------------------------------------------------- | :------------------------------------------------------------------------------------------------------- | :------------------------------------- |
| Evaluate    | Assess platform capability with prebuilt binaries. | Sample application running on the device.                                                                | Under an hour with a flashed device.   |
| Development | Learn the SDK and develop ROS 2 applications.      | Custom talker or listener ROS 2 node built with the QIR SDK toolchain.                                   | One to two days including reading.     |
| Production  | Customize the image and prepare for deployment.    | Custom `qcom-robotics-proprietary-image` built with KAS, or a Debian package published to a private PPA. | One to two weeks including validation. |

The scenarios build on each other — most teams pass through Evaluate on the way to Development, and through Development on the way to Production. All three scenarios and their runnable examples live on the [Scenarios](./scenarios) page.

## Robotics workflow decision tree

The following decision-tree diagram shows the full robotics workflow: start with the state of your device, branch on your goal, and land on the concrete tools and packages you use. Every leaf maps to a runnable procedure on the [Scenarios](./scenarios) or [End-to-end samples](./samples) page.

```mermaid theme={null}
flowchart TD
    Q1{Have a booted device<br/>with QIR SDK installed?}:::neutral

    Q1 -->|No| PROV{Which operating system?}:::neutral
    PROV -->|Qualcomm Linux| QDL[Flash with qdl<br/>Download prebuilt or local built images]:::proprietary
    PROV -->|Ubuntu| UBI[Flash the Ubuntu image<br/>apt install]:::proprietary
    QDL --> Q2
    UBI --> Q2

    Q1 -->|Yes| Q2{Purpose for using <br/>the QIR SDK}:::neutral

    Q2 -->|Try stock samples| EVAL[Evaluate scenario<br/>Run a system-monitor demo application]:::proprietary
    Q2 -->|Build my own ROS 2 node| Q3{Which operating system?}:::neutral
    Q2 -->|Ship a product| Q4{Which operating system?}:::neutral

    Q3 -->|Qualcomm Linux| QLIDEV[Use QIR SDK cross-compile toolchain<br/>colcon build → scp deploy]:::proprietary
    Q3 -->|Ubuntu| UBDEV[Development on Ubuntu<br/>colcon build on device<br/>source install/setup.bash]:::proprietary

    Q4 -->|Qualcomm Linux| KAS[Production on<br>Qualcomm Linux<br/>KAS build<br/>qcom-robotics-proprietary-image<br/>+ optional overlays]:::proprietary
    Q4 -->|Ubuntu| DEB[Production on Ubuntu<br/>Debian packaging<br/>publish to private PPA]:::proprietary

    classDef proprietary fill:#31017D,color:#ffffff,stroke:#31017D
    classDef neutral fill:#eeeeee,color:#000000,stroke:#999999
```

## Pick your combination

Use the picker to select a device, an operating system, and a scenario. The card at the bottom links to the matching tab on the Scenarios page.

<WorkflowNavigator />

## Next steps

Pick the entry point that matches how deep you want to go.

* [Scenarios](./scenarios) — pick a tab for Evaluate, Development, or Production. Each tab pairs the workflow diagram with a runnable example.