DepthAI Library

DepthAI library for interfacing with Luxonis DepthAI hardware. It’s written in C++ and offers Python bindings out of the box.

Important — You’re viewing the v3.x.y branch.

• For production projects that still rely on v2, check out the v2_stable branch.
• Need to migrate? Follow the step-by-step v2 → v3 Porting Guide.

Documentation

Documentation is available over at Luxonis DepthAI API

Examples

Examples for both C++ and Python are available in the examples folder. To see how to build and run them see README.md for more information. To build the examples in C++ configure with the following option added:

cmake -S. -Bbuild -D'DEPTHAI_BUILD_EXAMPLES=ON'
cmake --build build

Beta features

The beta namespace is a staging area for experimental DepthAI features. It allows new features to be developed and iterated on quickly before they are promoted to the main depthai namespace.

Beta features are well-developed, but minor API and behavioral changes may occur between DepthAI releases without notice.

In C++, beta nodes are available under dai::beta::node:

auto node = pipeline.create<dai::beta::node::ImgDetectionsFilter>();

In Python, they are available under dai.beta.node:

node = pipeline.create(dai.beta.node.ImgDetectionsFilter)

On-device execution of Beta nodes is supported only on RVC4. If running Beta nodes on RVC2, DepthAI automatically configures beta nodes to run on the host.

Multiple devices in one pipeline

A single dai::Pipeline can drive several devices. Devices become part of the pipeline explicitly with addDevice(...) or implicitly when a node is created with an explicit device; the first device becomes the master (default device) used by nodes created without one.

pipeline = dai.Pipeline(False)                    # no implicit device
devA = pipeline.addDevice("10.0.0.10")            # promoted to master
devB = pipeline.addDevice("10.0.0.11")

camA = pipeline.create(dai.node.Camera).build(dai.CameraBoardSocket.CAM_A)          # master
camB = pipeline.create(dai.node.Camera, device=devB).build(dai.CameraBoardSocket.CAM_A)

sync = pipeline.create(dai.node.Sync)             # host Sync aligns both streams
sync.setRunOnHost(True)
camA.requestOutput((640, 400)).link(sync.inputs["a"])
camB.requestOutput((640, 400)).link(sync.inputs["b"])

Key behaviors:

• Device-to-device links. Linking an output on device A to an input on device B inserts a host relay automatically at build time.
• Partial operation. Losing one device leaves its streams idle while the rest of the pipeline keeps running; the lost device reconnects on its own. Observe this via pipeline.getDeviceState(device) and pipeline.setDeviceStateCallback(...). The pipeline stops itself only when the last device is gone or when a device that consumes another device’s streams is lost for good. Call pipeline.setStopOnDeviceLoss(True) to stop when any device that runs a node is lost for good (reconnection exhausted); with device.setMaxReconnectionAttempts(0) it stops as soon as the disconnect is detected.
• Time. getTimestamp() values are host-clock based and comparable across devices; per-device getTimestampDevice() values are not (a host Sync node rejects the DEVICE timestamp source across devices at build).
• Source devices. After build, a host node can ask input.getSourceDevice() / inputs.getSourceDevices() which device produces each of its inputs.
• Per-device configuration. Every pipeline-level device setter/getter has a (device, ...) overload; the form without a device targets the master.
• Holistic record/replay is not supported with more than one device yet.

See examples/{cpp,python}/.../MultiDevice/ for frame sync, a device-to-device relay and a multi-device host node.

Running on the device (standalone)

The pipeline process may itself run on an RVC4 and use the local device over shared memory, with further devices attached over the network:

```python local = pipeline.addDevice(dai.DeviceInfo.local()) # this RVC4, no search timeout remote = pipeline.addDevice(“10.0.0.11”) # a remote device over TCP

File truncated at 100 lines see the full file

Changelog for package depthai

3.11.0 (2026-10-12)

## Features

• Multi-device pipelines
  • A single [Pipeline]{.title-ref} can now build and run nodes on multiple devices. Add a device with [pipeline.addDevice(...)]{.title-ref} or create a node with an explicit [device]{.title-ref} argument
  • Links between nodes on different devices are automatically relayed through the host
  • If one device disconnects, the other devices continue to run and the lost device reconnects automatically. Use [pipeline.setDeviceStateCallback(...)]{.title-ref} to monitor the device state
  • A [frame sync example](https://github.com/luxonis/depthai-core/blob/main/examples/python/MultiDevice/multi_device_frame_sync.py) and a [device-to-device relay example](https://github.com/luxonis/depthai-core/blob/main/examples/python/MultiDevice/device_to_device_relay.py) are available
• [_RVC4_] IFE sharing across camera sensors
  • Allows for running up to 5 cameras at once.
  • Different stream configurations are possible:
    • five concurrent cameras at up to 2.3 Gpix/s aggregate processing
    • 2×48MP @ ≤6.5fps + three others (≤20MP*)
    • 1×48MP @ ≤13.5fps + four others (≤20MP*)
  • Requires OS >= 1.44.0
• [_Beta_] MultiDeviceCalibration node
  • Calculates the extrinsics between multiple devices from synchronized camera frames
  • The result can be saved to JSON or applied with [pipeline.setMultiDeviceCalibration]{.title-ref}, which puts all devices in one shared coordinate system
  • A [Python example](https://github.com/luxonis/depthai-core/blob/main/examples/python/MultiDeviceCalibration/multi_device_calibration.py) and a [C++ example](https://github.com/luxonis/depthai-core/blob/main/examples/cpp/MultiDeviceCalibration/multi_device_calibration.cpp) are available
• [*RVC4*] ToFStereoFusion updates
  • Available in the [Depth]{.title-ref} node as the [TOF_STEREO_FUSION]{.title-ref} algorithm
  • [cropToOverlap]{.title-ref} crops the depth and confidence outputs to the overlap of the ToF and stereo cameras
• [*RVC4*] VPP accepts depth input
  • VPP can use aligned depth (for example, from a ToF sensor) instead of disparity
  • A [Python example](https://github.com/luxonis/depthai-core/blob/main/examples/python/Vpp/tof_stereo_vpp.py) and a [C++ example](https://github.com/luxonis/depthai-core/blob/main/examples/cpp/Vpp/tof_stereo_vpp.cpp) are available
• [_Beta_] Calibrated panorama stitching
  • [setUseInputCalibration(true)]{.title-ref} creates the panorama from the calibration of the input frames and skips feature matching
  • The output [ImgTransformation]{.title-ref} now describes the virtual camera of the panorama. A new [Cylindrical]{.title-ref} camera model is added for this
• New [Odometry]{.title-ref} message extends [TransformData]{.title-ref} with linear velocity. The Basalt and RTAB-Map VIO nodes now output it
• DetectionParser confidence and IoU thresholds can now be changed at runtime through [inputConfig]{.title-ref} messages
• [RVC4] Added support for [priority_hint]{.title-ref} argument to SNPE backend properties

## Bug fixes

• Dynamic calibration
  • Results with a translation-direction change of 15° or more are rejected with an explanatory message
  • The perpendicular optical-axis constraint is no longer applied to modular and FFC boards
• [RVC4] Better ToF filtering to reduce sensor bleeding
• [RVC4] Reduced ToF processing overhead
• [getStereoPairs]{.title-ref} now orders left and right cameras correctly, also for vertical and backward-facing pairs
• ImageAlign now uses the [ImgTransformation]{.title-ref} of the input frames instead of the EEPROM calibration.
• [InputQueue.send]{.title-ref} in Python now releases the GIL, which prevents a deadlock when the device queue is full
• Python exceptions in host nodes keep their original type, so [KeyboardInterrupt]{.title-ref} exits cleanly
• Added missing Python bindings for [MessageDemux.setRunOnHost]{.title-ref} and [setOtherModelFormat]{.title-ref}, which now accepts [bytes]{.title-ref} and NumPy arrays
• [RVC4] Resolved an issue with memory filling up in repeated reconnects to the device if the host dies first
• [RVC4] Resolved an issue in GPU ImgManip where it could reuse memory blocks before the operation would finish, resulting in missordered outputs
• [RVC4]
• [RVC2 PoE] Decreased network stack loads which can result in up to 20% lower CPU usage when streaming 1920x1080@30FPS BGR streams
• [RVC2] Device lifetime improvements should result in better stability

File truncated at 100 lines see the full file