> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.stereolabs.com/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.stereolabs.com/_mcp/server.

# ZED SDK 5.6

> **Note**
>
> Release notes of the ZED SDK 5.6 series. Patch releases are listed newest first. Download links and the full changelog, including ZED Tools and integrations, are available on the [ZED SDK 5.6 release page](https://www.stereolabs.com/developers/release/5.6).

## What's New

ZED SDK 5.6 delivers our most accurate depth yet, and faster depth across every mode. The new `NEURAL_MAX` mode sets a new bar for NEURAL accuracy, built for high-end GPUs such as Jetson AGX Thor and desktop GPUs. `NEURAL_LIGHT`, `NEURAL` and `NEURAL_PLUS` run in up to a third less time on Jetson Orin, Jetson Thor and DGX Spark, with better point cloud density, fewer flying pixels and a closer minimum depth range. The `INT8` 8-bit precision mode now covers all NEURAL depth modes for faster inference at a small cost in accuracy. On Jetson, `NEURAL_LIGHT` can even move to an accelerator and free the GPU for your application (experimental: the DLA with JetPack 6, the PVA with JetPack 6 and JetPack 7.2). And `QUALITY`, `ULTRA` and `PERFORMANCE` modes compute the same depth up to 3.8 times faster.

Tracking goes multi-camera. Multi-camera SLAM arrives through the Sensors API: several ZED and ZED One cameras mounted on one rig now track together and build a single shared map. Positional tracking can also take a motion prior from your own source, such as wheel odometry or an external VIO, to stay accurate through fast motion, low texture and occlusion. Simulation scales to any number of cameras, each with its own calibration, and their camera settings now reach the simulator.

The whole pipeline gets faster. Retrieving images and measures into CPU memory is now up to 3x faster, and SVO playback decodes straight into GPU memory. Multi-camera applications use less CPU time and GPU memory. In simulation, the acquisition stack has been further optimized to simulate even more cameras at once. Numerous fixes round out the release, across USB and GMSL camera recovery, image and IMU pairing, camera settings, lossless SVO recording on Jetson and the Sensors API.

> **Warning**
>
> **Before you upgrade**, check these changes:
>
> * GEN_3 area files are not backward compatible. Area files saved with `POSITIONAL_TRACKING_MODE::GEN_3` in this version can't be loaded by older versions.
> * Lossless SVO recordings on Jetson are much larger. Plan storage accordingly.
> * GMSL capture threads now request real-time priority. systemd services and containers must allow it.
> * Sensors API positional tracking now starts at each sensor's pose. Review any code that assumes all sensors start at the origin.

> **Note**
>
> On Jetson Thor, JetPack 7.2 (L4T 39.2) or newer is recommended: the ZED SDK works around TensorRT issues of JetPack 7.0 and 7.1 (L4T 38.x).

## 5.6.0

*Released: Nov 16, 2026*

### SDK

#### Depth

* Added `DEPTH_MODE::NEURAL_MAX`, the most accurate NEURAL depth mode, for high-end GPUs such as Jetson AGX Thor or for offline processing of SVO files. With the default `DEPTH_PRECISION::FP16` it gives its most detailed depth at HD1080 and larger resolutions, with up to about 30% less error than INT8 on thin structures such as fences, for up to about 1.5 GB of GPU memory; `DEPTH_PRECISION::INT8` takes up to about half the time and up to about 1.0 GB, and has the same minimum depth as FP16. On GPUs that support FP8 (Jetson Thor, RTX 40 and newer), both precisions run in FP8, faster with the same accuracy; the log reports the precision actually in use.
* Improved `DEPTH_MODE::NEURAL` and `NEURAL_PLUS` depth density: up to 2.5% more valid depth pixels at the default confidence threshold, with no loss in accuracy. Their inference speed is also drastically improved on Jetson Orin, Jetson Thor, and RTX 30, RTX 40 and RTX 50 series GPUs: depth networks take up to 22% and up to 40% less time respectively, for about the same GPU memory. Both (especially `NEURAL_PLUS`) are now able to perceive objects much closer to the camera (down to 3 cm close with `NEURAL` on ZED X Nano). Both are also more accurate (up to +10% on clean scenes) and more robust to image degradations such as vertical motion blur, lens droplets, occlusions and underexposure (up to 32% more accurate).
* Improved the speed of `DEPTH_MODE::QUALITY`, `ULTRA` and `PERFORMANCE`, for the same depth: computing it takes half the time with `QUALITY` and about 40% less with `ULTRA` and `PERFORMANCE` on Jetson Orin, and is 2.5 to 3.8 times faster with `QUALITY`, 1.8 to 2.3 times with `ULTRA` and 1.8 to 2 times with `PERFORMANCE`. With `RuntimeParameters::enable_fill_mode`, filling the depth also takes about half the time. Each camera also uses about 60 MB less GPU memory with `QUALITY` and 90 MB less with `ULTRA` at 1080p (system memory on Jetson).
* Improved the speed of `DEPTH_MODE::NEURAL_LIGHT` on all supported GPUs: the depth network takes up to 37% less time, for the same depth and about the same GPU memory.
* Added INT8 support (`InitParameters::depth_precision` set to `DEPTH_PRECISION::INT8`) to `DEPTH_MODE::NEURAL_LIGHT` and `NEURAL_PLUS` on Jetson Orin, Jetson Thor, and RTX 30, RTX 40 and RTX 50 series GPUs. INT8 trades some accuracy for speed: the `NEURAL_LIGHT` depth network takes up to 37% less time on Jetson Orin NX, and those of `NEURAL` and `NEURAL_PLUS` 5 to 12% less time than in FP16, for a slightly higher depth error. On Jetson Thor, and RTX 40 and RTX 50 series GPUs, `NEURAL_LIGHT` uses FP8, which brings its depth a third closer to the model's full-precision result in the same time. Applications that already requested INT8 with `NEURAL_LIGHT` or `NEURAL_PLUS`, which ran in FP16 until now, now get INT8. On other GPUs, these modes run in FP16 and the log says so; this includes `NEURAL`, which ran in INT8 there until now. Optimize the models ahead of time with `sl::AI_MODELS::NEURAL_DEPTH_INT8` or the new `sl::AI_MODELS::NEURAL_LIGHT_DEPTH_INT8` and `NEURAL_PLUS_DEPTH_INT8` (C++, C, Python and C# APIs), or ZED Diagnostic's `-nrlo_light_int8`, `-nrlo_int8` and `-nrlo_plus_int8`.
* Reduced the flying pixels of the `NEURAL_LIGHT`, `NEURAL` and `NEURAL_PLUS` depth modes, the "curtains" of points left floating between an object and the background in the point cloud, most visible behind plants, around people and around screens: at the default confidence threshold, many more of them are now removed. A small share of the removed points were valid depth along object edges, and they are still returned at a confidence threshold of 98 and above.
* Improved the depth stabilization (`InitParameters::depth_stabilization`) in every depth mode, for two cases. With a moving camera, static surfaces no longer show line artifacts. Moving people and objects are followed sooner and leave fewer ghosts behind them. The steadiness of a static scene seen by a still camera is unchanged. Thin structures such as foliage can lose a small share of their depth, and people standing almost still can show faint creases.
* Added `InitParameters::depth_compute_device`, experimental, to run `DEPTH_MODE::NEURAL_LIGHT` on an accelerator of the Jetson instead of the GPU, which leaves the GPU to the application: `sl::DEPTH_COMPUTE_DEVICE::DLA` on Jetson AGX Orin and Orin NX with JetPack 6, `sl::DEPTH_COMPUTE_DEVICE::PVA` on Jetson AGX Orin, Orin NX (JetPack 6 and 7.2) and Thor. When the accelerator cannot be used, the depth runs on the GPU and `open()` returns `ERROR_CODE::CONFIGURATION_FALLBACK`. In a container, both need `--runtime nvidia`, and the PVA with JetPack 6 also `--device nvidia.com/pva=all`.
* Reduced the scatter of distant points in the point clouds of the NEURAL depth modes, where the points of a far surface spread along the camera rays (most visible with `NEURAL_LIGHT` and `NEURAL`): ZED Depth Viewer shows 16 to 26% fewer scattered points, with edges, thin structures and depth accuracy unchanged and no added processing time.
* Improved the GPU time of the measure retrieval, with bit-identical results: up to 40% faster on Jetson Orin NX (about 1.5 ms instead of 2.5 ms per frame and per camera at 1920x1200), up to 12% higher total frame rate with 4 cameras, and up to 5% less GPU time with `DEPTH_MODE::ULTRA` in applications that retrieve the point cloud.
* Improved the speed of `Camera::retrieveVoxelMeasure`: the voxelization of the point cloud is about 4 times faster on Jetson AGX Thor, 7 to 11 times faster on desktop GPUs and 2.5 times faster on Jetson Orin with every depth mode. The voxel centroids are also closer to the exact mean of their points.
* Fixed the NEURAL depth modes returning invalid depth (`NaN`) instead of too close (`-inf`) at close range.
* Fixed `DEPTH_MODE::NEURAL` and `NEURAL_LIGHT` returning mostly invalid depth, in horizontal bands, on Jetson Thor with JetPack 7.0 and 7.1 (L4T 38.x) due to a TensorRT bug.
* Fixed opening a camera with a NEURAL depth mode on Windows after calling `sl::checkAIModelStatus()` or `sl::optimizeAIModel()` in the same application: `open()` failed with `ERROR_CODE::CORRUPTED_SDK_INSTALLATION` and the application then crashed (access violation in `nvinfer_10.dll`). It affected applications that also use TensorRT, directly or through another library.
* Fixed the application crashing when a camera was closed or destroyed after `open()` failed with `ERROR_CODE::CORRUPTED_SDK_INSTALLATION` with a NEURAL depth mode, as with an incomplete ZED SDK installation.
* Fixed `InitParameters::allow_depth_cuda_graph` with several cameras in one application: when the recording of the depth computation of a camera failed, most often as the cameras started together, its `grab()` returned `ERROR_CODE::CUDA_ERROR` and the camera stopped. The recording is now retried on the next frames, then the regular computation is used.
* Fixed `Camera::retrieveVoxelMeasure` in `REFERENCE_FRAME::WORLD` measuring distances from the world origin instead of the camera: it returned fewer voxels as the camera moved away from its starting point, failed beyond `InitParameters::depth_maximum_distance`, and sized the depth-adaptive voxels wrongly. Its first call after `open()` also returned voxels without color, and so did a colored point cloud retrieved afterwards in that frame at the same resolution.
* Fixed the smoothing of `MEASURE::NORMALS` with `DEPTH_MODE::QUALITY` and `PERFORMANCE`, which used wrong settings: the normals change slightly (about 1 degree in median), and retrieving them takes about 20% less GPU time on Jetson Orin.
* Fixed the right side measures (`InitParameters::enable_right_side_measure`): the NEURAL depth modes marked occluded areas as invalid in some runs and not in others (they are now always marked invalid, as with the other depth modes), the first `MEASURE::NORMALS_RIGHT` retrieved with `DEPTH_MODE::ULTRA` contained no valid normal, and `VIEW::NORMALS_RIGHT_GRAY` showed the shading of the left normals.
* Fixed the confidence map of `DEPTH_MODE::ULTRA`, the `MEASURE::NORMALS` of `DEPTH_MODE::QUALITY` and `PERFORMANCE`, and the voxel centroids of `Camera::retrieveVoxelMeasure` varying slightly between two runs on the same input: they are now the same at each run.
* Fixed the temporal filtering of `RuntimeParameters::enable_fill_mode` with `DEPTH_MODE::PERFORMANCE`, `QUALITY` and `ULTRA`, which did not use the previous image: the filled depth is now more stable from frame to frame (up to 23% less variation on our test recordings).
* Fixed the disparity and the confidence retrieved with `RuntimeParameters::enable_fill_mode` sometimes being the unfilled ones while publishing to a Fusion in the same process (`CommunicationParameters::setForSharedMemory`).

#### SLAM

* Added motion prior fusion to `GEN_3` positional tracking: it can now fuse motion from your own source (wheel odometry, external VIO, GNSS) through `Camera::ingestMotionPrior()`, keeping it accurate in fast motion, low texture or occluded scenes. Fusion status is reported in `PositionalTrackingStatus::relative_pose_fusion_status`. Available in the C++, C, Python and C# APIs.
* Improved `POSITIONAL_TRACKING_MODE::GEN_3` accuracy with IMU fusion, especially with 200 Hz IMUs such as those of GMSL cameras. When the images cannot be tracked for a moment (darkness, blur, a view without texture), the orientation now follows the IMU, so tracking no longer resumes with a lasting heading or tilt error.
* Sped up `GEN_3` tracking with `PREFER_GPU` by offloading more computation to the GPU (identical results).
* Reduced `POSITIONAL_TRACKING_MODE::GEN_3` processing time with a single camera when `PositionalTrackingParameters::enable_area_memory` is disabled, so fewer frames are dropped at 30 and 60 Hz, especially on Jetson.
* Added the experimental `PREFER_ACCELERATORS` compute preference: `GEN_3` tracking offloads work to the PVA on Jetson AGX Orin, Orin NX (JetPack 6 and 7.2) and Thor with identical poses, cutting CPU time by up to \~25% on Orin and 55–70% on Thor (+1–2 ms per frame); elsewhere it falls back to `AUTO`.
* Changed the `POSITIONAL_TRACKING_MODE::GEN_3` area file format to store the map of several cameras tracked together (`MULTI_SENSOR_TRACKING_MODE::SINGLE_BODY` in the Sensors API), with the position of each camera on the rig. Area files saved with this version, including with a single camera, cannot be loaded by ZED SDK 5.5 or earlier. Area files from earlier versions still load, and are saved in the new format the next time `saveAreaMap()` is called, so keep a copy of the original if an older SDK still needs it.
* Changed `GEN_3` to reject area files when `enable_area_memory` is off: `enablePositionalTracking()` returns `INVALID_AREA_FILE` if `area_file_path` is set, and `saveAreaMap()` returns `SPATIAL_MEMORY_DISABLED`, as with `GEN_1`.
* Fixed `getPositionalTrackingKeyframes()` with `GEN_3` always returning meters; positions now follow `coordinate_units`, so drop any manual conversion from meters.
* Fixed `GEN_3` frame drops: occasional 200–250 ms frames with fisheye cameras, and 100+ ms pauses on loop closure with large area memory maps.
* Fixed `GEN_3` on fisheye cameras reporting poses and keyframes up to \~1° off from the depth and point clouds.
* Fixed `saveAreaMap()` and `disablePositionalTracking()` hanging with `GEN_3` when the area file can't be written; they now fail and `getAreaExportState()` returns `FILE_ERROR`.
* Fixed a partially readable area file loading silently and never relocalizing: it now logs a warning.
* Fixed `GEN_3` with IMU fusion staying at the origin on simulated cameras without a full-rate IMU (e.g. Isaac Sim streams or their SVO2s); tracking now falls back to visual tracking, using per-frame orientation when available.

#### General

* Reduced the time of `Camera::retrieveImage` and `Camera::retrieveMeasure` into CPU memory (`sl::MEM::CPU`, as in the samples): a 1080p point cloud takes 1.8 ms instead of 5.4 ms on Jetson Orin NX, with 8 cameras on a desktop GPU the retrievals take less than half the time, and retrieving into a `sl::Mat` allocated by the application is up to about 1.9 times faster. The CPU memory the SDK allocates for these outputs is now page-locked and reused while a camera is open, and each camera uses about 80 MB less memory at 1080p on Jetson Orin NX. `ZED_SDK_DISABLE_PINNED_RETRIEVE=1` restores the previous allocation.
* Reduced the CPU usage of several cameras in one application on desktop Linux and DGX Spark, with any depth mode: from 2 open cameras, a camera waiting for the GPU no longer keeps a CPU core busy, which saves 0.8 to 5 CPU cores with 2 to 8 cameras at the same frame rate, especially when the GPU is heavily used. `ZED_SDK_CUDA_SPIN_WAIT=1` restores the previous behavior, which can give up to 4% more frames with two cameras on some PCs. Jetson already did not keep a core busy; Windows is unchanged.
* Improved the total frame rate of several cameras in one application with non NEURAL depth modes: the depth no longer creates and destroys GPU resources at every frame, which made the cameras wait for each other. About 10% more frames with 4 to 8 cameras.
* Improved calibration loading in `open()`: when no calibration file is on the host, the SDK now reads the calibration stored in the camera and downloads the factory calibration only if the camera doesn't store one. Cameras with stored calibration now open without internet access and without waiting for a download. A calibration file already on the host is still used first. To restore the previous behavior (download first), set `ZED_SDK_CALIB_PREFER_DOWNLOAD=1`.
* Improved the self-calibration run at `open()`: outlier matches are now rejected as intended, the wide field of view of fisheye lenses is handled, and the rotation it corrects stays within 1.5 degrees of the factory calibration. Its result can differ slightly from previous versions, mostly on ZED 2i and fisheye cameras.
* Added `ERROR_CODE::AI_MODEL_NOT_AVAILABLE` (`SENSORS_ERROR_CODE::AI_MODEL_NOT_AVAILABLE` in the Sensors API), returned by `open()` with a NEURAL depth mode, `enableObjectDetection()` and `enableBodyTracking()` when the AI model is missing and cannot be downloaded, for example without internet access. These calls returned `ERROR_CODE::CORRUPTED_SDK_INSTALLATION`, and the log of a NEURAL depth mode spoke of object detection instead of the failed download. A model that is present but cannot be optimized for the GPU now returns `ERROR_CODE::FAILURE`, with the reason in the log. Available in the C++, C, Python and C# APIs.
* Reduced the CPU cost of SDK logging. On Linux, debug messages written to the console now appear within 100 ms instead of immediately; `ZED_SDK_LOG_FLUSH_EVERY_MESSAGE=1` writes each one immediately, for example to keep the last messages before a crash.
* Fixed AI model optimization failures: a camera could fail to open while another camera or application was saving the same optimized model, a NEURAL depth mode failed to open when the optimized model could not be saved (full disk, or no write access to the model folder), and a damaged optimization cache file made every later model optimization crash the application. When the optimized model cannot be saved, depth now runs for the session and the optimization runs again at the next start, and a damaged optimized depth model is rebuilt during the same `open()` instead of making it fail once.
* Fixed `open()` overwriting or deleting a calibration file it could not use, such as a file made with ZED Calibration that has invalid values or no parameters for the camera resolution: it was overwritten by the downloaded factory calibration. The previous file is now saved as `SN<serial>.conf.bak` when a valid calibration replaces it, and kept in place otherwise.
* Fixed `open()` failing with `ERROR_CODE::CALIBRATION_FILE_NOT_AVAILABLE` (since ZED SDK 5.1) when `InitParameters::optional_settings_path` is a folder with no usable calibration file for the camera: the SDK did not fetch the calibration in that case. It now reads the calibration stored in the camera, or downloads it, and saves it in that folder, as it does with the default settings folder.
* Improved the message of `open()` when the calibration file has no parameters for the resolution of the camera or SVO: it now names the missing resolution, for example 1920x1200, instead of reporting invalid values in the file.
* Fixed `open()` returning `ERROR_CODE::NO_GPU_DETECTED` when the NVIDIA driver is too old for the CUDA version of the ZED SDK: it now correctly returns `ERROR_CODE::NVIDIA_DRIVER_OUT_OF_DATE`, and the error message asks the user to update the driver.
* Fixed `Camera::retrieveImage` and `Camera::retrieveMeasure` with `sl::MEM::BOTH` into an empty `sl::Mat` returning a `Mat` that held CPU memory only (an invalid GPU pointer) and was reallocated at every call.
* Fixed `Camera::startRegionOfInterestAutoDetection()` on desktop GPUs switching the calling thread to a new CUDA context, which used about 160 MB of GPU memory: CUDA work done afterwards by the application in that thread ran in that context. The scene motion it uses is now also measured on Jetson and on desktop GPUs older than Turing, where it had always been zero since ZED SDK 4.1.
* Fixed the timestamps of the SDK log messages, on the console and in the log file, being labelled UTC although they are in local time. They now end with the UTC offset instead, for example `[2026-11-04 19:04:23 +01:00]`.

#### Capture

* Added `sl::VIDEO_SETTINGS::COLOR_CORRECTION_MATRIX` to apply your own color correction matrix, which converts the sensor RGB values to linear sRGB on ZED X cameras. It is meant for applications that need a specific color rendering, typically to match several cameras to one another or to a reference, with a matrix computed from images of a color chart.
* Added `InitParameters::imu_accelerometer_range`, `imu_gyroscope_range` and `imu_sampling_rate` to configure the IMU of ZED X family cameras. A smaller range gives a finer resolution for slow, precise motion (down to ±3 g and ±250 deg/s), a larger one avoids saturated readings under strong shocks or fast rotations (up to ±24 g and ±2000 deg/s), and `IMU_SAMPLING_RATE::HZ_400` doubles the gyroscope rate for applications that need more motion samples between frames. The defaults are unchanged (±12 g, ±1000 deg/s, 200 Hz), and `getCameraInformation().sensors_configuration` reports the values in use. The ranges and the 400 Hz rate require [ZED X Driver 1.5.0](/docs/development/zed-x-driver/release-notes/1-5#150) or newer: with an older driver the camera keeps its defaults and a warning is logged. `IMU_SAMPLING_RATE::OFF` opens a camera without its IMU.
* Reduced the CPU usage of the image validity check (`InitParameters::enable_image_validity_check`, enabled by default), with the same results: about 0.3 CPU core less per camera on Jetson AGX Thor, and 1.4 cores less with 4 cameras on a desktop PC.
* Improved the recovery of USB cameras after a short disconnection: images resume as soon as the camera is back, with its video settings kept, instead of after a timeout of several seconds. A camera that stays connected but stops sending images is restarted after 5 seconds without images.
* Added ZED Mini support to `sl::Camera::reboot()` and to `sl::Camera::reboot(sl::INPUT_TYPE::USB)`. Rebooting is supported only on ZED Mini cameras acquired after September 2026, with firmware v520.
* Fixed the IMU data paired with an image sometimes coming from the previous or next frame, on GMSL cameras (ZED X and ZED X One families) and on Linux with USB cameras. With Linux USB cameras, the image timestamp could also come from another frame, so two consecutive images could share the same timestamp. SVO files recorded with these cameras had the same problems; files recorded with this version are correct, while files recorded before keep them.
* Fixed `InitParameters::grab_compute_capping_fps` delaying images by up to one capping period (about 200 ms at 5 FPS): `grab()` now processes the newest image. The cap now also applies to stream inputs, where it had no effect.
* Fixed GMSL cameras restarting after a single correctable capture error with JetPack 6.2.2, JetPack 7.1 and newer, which usually also restarted the Argus daemon and stopped every GMSL camera for several seconds: the affected frame is now dropped, and a camera is restarted only when most of its frames fail.
* Fixed applications using several GMSL cameras not recovering when the Argus daemon restarted: a camera could stay stopped until the application was restarted, or `close()` could block the application.
* Fixed the Argus daemon (`nvargus-daemon`) sometimes crashing when the SDK restarted a GMSL camera that had stopped sending images.
* Fixed closing GMSL cameras occasionally hanging: one camera never closed, the others then took about 30 seconds each to close, the application usually crashed, and the next application could fail to open the cameras.
* Fixed unplugged GMSL cameras being reported late or with the wrong error by `grab()`: it now returns `ERROR_CODE::CAMERA_NOT_DETECTED` and logs the disconnection, or `ERROR_CODE::CAMERA_REBOOTING` while the camera restarts, as `sl::Camera` does.
* Fixed restarting `zed_x_daemon` (for example with `sudo systemctl restart zed_x_daemon`) while GMSL cameras were open, which could crash the application or leave a camera stopped (in a container, requires sharing the host's processes, `--pid=host`).
* Fixed opening several GMSL cameras at the same time from different threads of one application, which could make `open()` fail or crash.
* Fixed two issues with USB cameras on Windows: closing, rebooting or recovering a camera could crash the application while a ZED Mini, ZED 2 or ZED 2i stayed open in it, and `open()`, `grab()` or `close()` could block for minutes, or never return, when a camera stopped answering.
* Fixed two issues with USB cameras on Linux: opening several cameras at the same time from different threads crashed the application, and opening a USB camera reset the sensors of the other connected ZED cameras.
* Fixed stale data during a USB camera recovery. With the default synchronous recovery (`InitParameters::async_grab_camera_recovery` off), the `grab()` that recovered the camera returned the image captured before the failure; it now returns a new image, or `ERROR_CODE::CAMERA_REBOOTING` if none arrives within 2 seconds. While the camera was disconnected, `getSensorsData()` with `TIME_REFERENCE::CURRENT` returned the last IMU sample, then blocked until the camera was back; it now returns `ERROR_CODE::CAMERA_NOT_DETECTED`.
* Fixed `open()` on Windows failing to open an available USB camera: the default `open()` tried a camera already in use, then failed after `InitParameters::open_timeout_sec`. A camera in use is now listed as `sl::CAMERA_STATE::NOT_AVAILABLE`, and requesting it by id or serial number returns `ERROR_CODE::CANNOT_START_CAMERA_STREAM` right away.
* Fixed `open()` leaving the camera reported as opened after failing on corrupted first frames (USB and GMSL), so every retry returned `ERROR_CODE::INVALID_FUNCTION_CALL` until `close()`, and `open()` hanging when a ZED Mini was unplugged during the call.
* Fixed `open()` by serial number occasionally opening another USB camera when a camera was plugged in during the open.
* Fixed `CAMERA REBOOTING` being logged on every `grab()` call while a USB camera restarted: it is now logged once per restart.
* Fixed the first IMU samples after `open()` on the ZED X family of cameras coming from the previous session, and, with ZED X Driver 1.4.2 or newer, IMU timestamps from `getSensorsData()` occasionally going backwards by a few milliseconds. With these drivers, IMU timestamps now carry the sample time, a few milliseconds earlier than before.
* Fixed a ZED X One 4K failing to open when the ZED X Driver reports its motion sensors as unreachable: it now opens with images only, `isSensorAvailable()` returns false for its motion sensors, and a warning is logged at open, and by `enablePositionalTracking()` with IMU fusion, which then tracks from the images only. With `FLIP_MODE::AUTO`, such a camera keeps its images unflipped; set `FLIP_MODE::ON` or `OFF` instead.
* Fixed the image health checks: `HealthStatus::low_image_quality` (and `low_depth_reliability` with depth) was not raised when one image of the stereo pair was black or much darker than the other, for example with a covered lens or a failing sensor, and very dark scenes caused sporadic `ERROR_CODE::CORRUPTED_FRAME` returns from `grab()`.
* Fixed `getCameraInformation().sensors_configuration` on ZED X family cameras: it reported a ±8 g accelerometer range with a resolution 1.5 times too fine (the IMU runs at ±12 g) and on ZED X One a 400 Hz IMU rate while the IMU ran at 200 Hz.
* Fixed `setCameraSettings()` returning `SUCCESS` for a setting that was not applied, on `sl::Camera`, `sl::CameraOne` and `sl::Sensors`, and made its errors specific: `INVALID_FUNCTION_PARAMETERS` for a setting the camera does not support or an AEC/AGC region outside the image, `INVALID_FUNCTION_CALL` on SVO playback, `CAMERA_NOT_INITIALIZED` when the camera or stream is gone, and `FAILURE` when the camera refused the value. On a stream input, `SUCCESS` means the request was sent to the streaming camera.
* Fixed `getCameraSettings()` returning wrong values on the ZED X family of cameras while a setting was automatic or after switching it back to manual: `WHITEBALANCE_TEMPERATURE` could read back an impossible value such as -1700, and `EXPOSURE` and `GAIN` read back -1. Most visible in ZED Explorer and ZED Depth Viewer, where the sliders jumped to those values when unchecking the auto boxes.
* Fixed exposure and gain requests being undone or ignored on the ZED X family of cameras even when `setCameraSettings()` returned `SUCCESS`.
* Fixed a manual `EXPOSURE` or `GAIN` being ignored on USB cameras when set back to its previous value after the automatic exposure had run (`AEC_AGC` set to 1, or `EXPOSURE` set to -1): the camera turned the automatic exposure off but kept its last automatic values. A value close to the previous one could also be applied wrongly, giving an image several times too bright.
* Fixed `setCameraSettings()` ignoring a return to automatic mode: `EXPOSURE` or `GAIN` set to -1 after `AEC_AGC` was set to 0 or after a manual `GAIN`, and `WHITEBALANCE_TEMPERATURE` set to -1 after `WHITEBALANCE_AUTO` was set to 0.
* Fixed the `AUTO_EXPOSURE_TIME_RANGE`, `AUTO_ANALOG_GAIN_RANGE` and `AUTO_DIGITAL_GAIN_RANGE` settings on the ZED X family of cameras: a range with the minimum equal to the maximum, which fixes the value, was applied but not reported by `getCameraSettings()` and was lost when `AEC_AGC` was switched off and on again, and a bound of -1 on `AUTO_EXPOSURE_TIME_RANGE` did not select the camera limit as documented, so the range was not applied.
* Fixed `AE_ANTIBANDING` on the ZED X family: `getCameraSettings()` always returned -1 instead of the mode in use, and setting it to `VIDEO_SETTINGS_VALUE_AUTO` (-1) kept the previous mode instead of restoring the default. The documented default is corrected to `AUTO`, the mode cameras have always opened in (it said `OFF`).
* Fixed `sl::CameraOne` keeping the camera settings of the previous session after `close()` and `open()`: `setCameraSettings()` ignored a value already set before closing, which left the camera on its default, and `getCameraSettings()` could report that old value.
* Fixed `getCameraSettings()` always returning `ERROR_CODE::FAILURE` for `LED_STATUS`: it now returns the LED state on USB cameras. On cameras without a status LED, or with firmware that cannot switch it, `getCameraSettings()` and `setCameraSettings()` return `ERROR_CODE::INVALID_FUNCTION_PARAMETERS` (the setter returned `SUCCESS` without switching the LED).
* Fixed `retrieveImage()` with `VIEW::LEFT_NV12_UNRECTIFIED` and `RIGHT_NV12_UNRECTIFIED`: with `sl::Camera`, they returned `SUCCESS` without filling the `Mat` on inputs without a native NV12 buffer. USB cameras, SVO files and streams now return `ERROR_CODE::INVALID_FUNCTION_CALL`, or `ERROR_CODE::FAILURE` when the buffer of this frame is missing.

#### Zero-Copy Capture (Jetson Only)

* Changed the experimental zero-GPU rectification mode (`ZED_SDK_EXPERIMENTAL_RECTIFICATION_BACKEND` set to `VIC` or `CPU`) to remap a frame only when `retrieveImage(RawBuffer&, true)` first asks for its rectified pair (about 11 ms at 1920x1200 on Jetson AGX Orin with `VIC`): `grab()` no longer waits for it, and frames that are not retrieved cost nothing.
* Fixed `retrieveImage(RawBuffer&, true)` called from another thread while `grab()` runs, in the experimental zero-GPU rectification mode: it could fail, turn the mode off for the rest of the session, or crash. In this mode it now waits for `grab()`, as `retrieveMeasure()` does.
* Fixed `retrieveImage()` returning an unfilled (black or garbage) image for the rectified left and right views at 896 pixels wide or less, in the experimental zero-GPU rectification mode with `DEPTH_MODE::NONE`: these views are now rectified on the GPU when requested, at full resolution.

#### Recording & Streaming

* Improved the SVO playback speed on desktop GPUs, DGX Spark and Jetson Thor: SVO2 frames now decode straight into GPU memory, and Jetson Thor uses the GPU decoder instead of V4L2. Playback is up to 2x faster, uses less CPU and gives the same images. For example, a 1920x1200 recording with `NEURAL_LIGHT` goes from 180 to 277 FPS on an RTX 3090. To restore the previous behavior, set `ZED_SDK_SVO_HOST_DECODE=1` (desktop) or `ZED_SDK_SVO_V4L2_DECODER=1` (Thor).
* Fixed `SVO_COMPRESSION_MODE::H265_LOSSLESS` and `H264_LOSSLESS` recordings being lossy on Jetson with JetPack 6 since ZED SDK 4.0: the files were 1 to 2% of the raw image size instead of the documented 25%, and the played-back images lost fine detail and noise compared with the live ones. They are now near lossless, so the files are much larger, about 12 times with `H265_LOSSLESS` and 30 times with `H264_LOSSLESS` (about 75 MB/s with `H265_LOSSLESS` for a ZED X Mini at HD1200 and 30 FPS). `SVO_COMPRESSION_MODE::LOSSLESS` stays the mode for images identical to the live ones.
* Added support for any number of simulated cameras: the SDK now gives each virtual camera its own serial number and calibration, slightly different from one camera to the next like real units. Recordings of a simulated camera embed its calibration. Requires this release on both the simulator and the receiving side. As on a live camera, self-calibration runs unless `InitParameters::camera_disable_self_calib` is set, which is recommended for reproducible simulation results.
* Added camera settings to simulated cameras: on the receiving side, `setCameraSettings()` now reaches the simulator for the settings it applies and returns `ERROR_CODE::INVALID_FUNCTION_PARAMETERS` for the others instead of `SUCCESS`, and `getCameraSettings()` returns the exposure time and gains of each frame, also kept in SVO recordings. Requires this release on the simulator side, and on the receiving side for unsupported settings to be refused.
* Fixed opening SVO2 files whose recording was interrupted. Since ZED SDK 5.3, `open()` had crashed the application on such a file, or an interrupted copy, when it could not be repaired in place (read-only or full storage, file in use): the file now opens and plays back the frames recorded before the interruption, with seeking and IMU data as from a repaired file. For an encrypted file damaged by an interruption, `open()` reported a wrong or missing `InitParameters::svo_decryption_key` even with the right key; it now reports that the file is damaged, as encrypted files cannot be repaired.
* Fixed `sl::CameraOne::close()` crashing the application when the camera was still streaming (`enableStreaming()` without `disableStreaming()`), which could also leave GMSL cameras unable to open in the next run.
* Fixed a memory leak in applications receiving a stream on the same machine through local shared memory (IPC): memory grew for as long as the stream was open, whether `grab()` was called or not.
* Fixed `setSVOPosition()` sometimes landing on the wrong frame: on SVO2 files when seeking a few frames ahead, for example when stepping through a file frame by frame, which returned wrong images (corrupted images with H.264); and on Jetson with SVO files older than the SVO2 format.
* Fixed `InitParameters::svo_real_time_mode` returning the frame before the one sought by `setSVOPosition()`, showing the frame before the one paused on with `pauseSVOReading()`, and skipping the first frame of the file. With a ZED One (`InitParametersOne::svo_real_time_mode`), `setSVOPosition()` restarted the playback from the first frame.
* Fixed SVO playback on DGX Spark and other ARM desktops never returning the last frame of files recorded in H.264 (`SVO_COMPRESSION_MODE::H264` or `H264_LOSSLESS`): `grab()` returned `ERROR_CODE::END_OF_SVOFILE_REACHED` one frame early, as on x86 desktops before ZED SDK 5.5.1.
* Fixed the IMU data of streams arriving later than the image: one frame late for streams received on the same machine through local shared memory (IPC), Isaac Sim streams included (three frames with "Stream Depth", whose image and depth also carried the timestamp of the frame rendered two frames earlier), and two frames late for Isaac Sim stereo and "Stream Depth" streams sent over the network. An application that opened an Isaac Sim stream before the simulation started could also get no IMU data for the whole session. Requires this release on the sending side.
* Fixed streams received over the network losing all their IMU data once the sender's timestamps were more than 10 seconds away from the receiving machine's clock: `getSensorsDataBatch()` returned no samples, for example with a sender whose clock is not synchronized with the receiver, or with an Isaac Sim stream after the simulation had run slower or faster than real time for a while (about 100 seconds at 90% of real time). Only the receiving side needs this release.
* Fixed `getSensorsData()` with `TIME_REFERENCE::CURRENT` on a stream input: while `grab()` ran, it returned `SUCCESS` with empty IMU data about half of the time, and otherwise an older sample, which it also took away from the samples `grab()` pairs with the images. It now returns the latest IMU sample received, or `ERROR_CODE::SENSORS_NOT_AVAILABLE` before the first one.
* Fixed SVO2 files recorded from a stream that carries one IMU reading per frame, such as an Isaac Sim stream, playing back without IMU data: `getSensorsData()` returned no orientation or acceleration, and `POSITIONAL_TRACKING_MODE::GEN_1` with `enable_imu_fusion` returned `ERROR_CODE::SENSORS_DATA_REQUIRED`. These files, including those already recorded, now play back the IMU of each frame. Recordings of a stream also keep its `SensorsConfiguration::camera_imu_transform` instead of saving an identity transform.
* Fixed SVO2 files recorded from an Isaac Sim stream received over the network holding the left image in place of the right one, with the default `RecordingParameters::transcode_streaming_input` set to false. Streams that send the left and right images separately, as Isaac Sim does, are now always re-encoded when recorded.
* Fixed SVO recordings of a ZED X or ZED X One stream losing the exposure time and gains of each frame: `getCameraSettings()` failed on them at playback, and `getTimestamp(TIME_REFERENCE::IMAGE_CENTER_OF_EXPOSURE)` returned 0. Only recordings of the stream as received were affected, not re-encoded ones (`RecordingParameters::transcode_streaming_input`).
* Fixed errors such as `Capture Plane:Timed out waiting for dqthread` being logged on Jetson Thor each time an SVO file, a recording or a stream started or stopped, often with garbled characters. Nothing had failed: images and recordings were not affected.

#### Sensors API

* Added the `SINGLE_BODY` multi-sensor mode: ZED and ZED One cameras on one rigid body are tracked together in a shared map. Requires `GEN_3`, at least one ZED stereo camera, and hardware-synchronized cameras with matching resolution and frame rate. C++ and Python.
* Added `Sensors::ingestMotionPrior()` to feed your own motion source to Sensors API tracking, like `Camera::ingestMotionPrior()`, applied to the rig in `SINGLE_BODY` mode or to the named ZED camera otherwise, with `sensor_transform` given in the `BASELINK` frame (C++ and Python).
* Added `Sensors::retrieveVoxelMeasure()`, the point cloud of a ZED camera decimated on a voxel grid as `Camera::retrieveVoxelMeasure()` returns it, in `RuntimeSensorsParameters::reference_frame`. It supports the left point cloud measures and is not available in pipelined mode. Available in the C++ and Python APIs.
* Changed the tracking of each sensor to start at its sensor pose (unless `initial_world_transforms` is set), so `WORLD` matches `BASELINK` at start and a ZED One moves with the tracked cameras; `getPosition()` with `BASELINK` returns per-frame motion in `BASELINK` axes, and `resetPositionalTracking()` takes a `BASELINK` pose.
* Changed object detection and body tracking to no longer turn on positional tracking: `getPosition()` stays `POSITIONAL_TRACKING_STATE::OFF` until `enablePositionalTracking()` is called.
* Fixed `enableObjectDetection()` crashing when `sensors_ids` held a ZED One, a LiDAR or `defaultSensorDeviceIdentifier()`: object detection and body tracking now skip the sensors other than ZED stereo cameras, and are no longer left running on some cameras when they fail on another.
* Fixed sensor parameters given in a unit other than `InitSensorsParameters::coordinate_units` not being converted: `depth_maximum_distance = 10` with `UNIT::METER` became a 10 mm limit under the default `UNIT::MILLIMETER`. Sensor poses are expressed in `InitSensorsParameters::coordinate_units`, as now documented.
* Fixed WORLD point clouds, objects and bodies being offset from where `getPosition()` placed a sensor that has a sensor pose. Also fixed in BASELINK and WORLD: normals moved by the translation, LiDAR points without a return moved onto the LiDAR position, most `LIDAR_MEASURE` point clouds (`XYZ_INTENSITY`, `XYZ_RANGE`, ...) left in the sensor frame, and `retrieveObjects()` and `retrieveBodies()` moving the detections again at each call without a new detection.
* Fixed the pipelined execution mode (`SENSORS_EXECUTION_MODE::PIPELINED`) refusing object detection, body tracking and positional tracking: modules, recording and streaming can now be changed at any time. Also fixed in that mode: a possible crash in `close()`, GPU retrieves returned in CPU memory, batched retrieves being refused, and sensors not being grabbed, so not recorded or streamed, when none of their outputs was retrieved.
* Fixed recording and streaming several sensors at once: sensors without a file in `RecordingSensorsParameters::video_filenames` all wrote the same file, all cameras used the same streaming port, and a failure on one sensor left the others running. Each sensor now records into a file named after it, and each camera streams on its own port (`port`, `port + 2`, ...).
* Fixed `add()` failing for a ZED One given as `sl::InitParameters` (live, SVO or stream), which is now added as a ZED One, and rejecting a camera that opens with a warning. The default sensor identifier now designates the single sensor of the instance, a ZED One or a LiDAR included, instead of only a ZED stereo camera.
* Fixed `process()` and the batched retrieve calls returning `SUCCESS` when no sensor produced data or when the requested sensor failed, and `resetPositionalTracking()`, the region of interest functions, `ingestDataIntoSVO()` and `retrieveSVOData()` returning `SUCCESS` instead of the error of the sensor. `getErrorCodes()` now lists the sensors of the last call only.
* Fixed `syncSVO()` delivering the first, unsynchronized frame of each file on the next `process()`, and `SENSORS_SYNC_POLICY::DROP_STALE` reporting the most recent data as stale while a stalled sensor was reported fresh.
* Fixed `isPositionalTrackingEnabled()` returning `true` with no tracked sensor, `getCameraInformation()` of a ZED One lacking its calibration, `getRecordingStatus()` and the batched `getTimestamp()` and `getCurrentFPS()` leaving out LiDARs, and the `verbose`, `maximum_working_resolution`, `sdk_gpu_id` and `sdk_cuda_ctx` settings of `InitSensorsParameters` being ignored.
* Fixed calls given only sensor ids that are not added, or only sensors of a type the call does not take, returning `SUCCESS` without doing anything: the batched getters and retrieve calls, `getPosition()`, `resetPositionalTracking()`, `enableRecording()` and `enableStreaming()` now return `INVALID_FUNCTION_PARAMETERS`.
* Also fixed `syncSVO()` moving every file to the end of a file already played to its end, `setRuntimeSensorsParameters()` not applying the depth confidence threshold to the cameras added afterwards, `setObjectDetectionRuntimeParameters()` stopping at the first camera that returned a warning, and, in pipelined mode, `ingestCustomBoxObjects()` and `ingestCustomMaskObjects()` working on the first frame only instead of being refused, and the region of interest and color correction matrix settings being applied while the camera grabbed.

#### Body Tracking

* Fixed body tracking with `BodyTrackingParameters::enable_body_fitting` on `BODY_18` and `BODY_34` sometimes giving a person far from the camera (about 10 m and more, away from the image center) a bounding box and skeleton covering most of the image, kept until that person's track ended.

#### Spatial Mapping

* Fixed `sl::Mesh::applyTexture()` taking minutes instead of seconds when other processes kept the CPU busy, and leaving the OpenMP thread count of the calling thread set to 4 afterwards.

#### Fusion

* Fixed `startPublishing()` failing with `ERROR_CODE::INVALID_FUNCTION_CALL` when the camera was opened with `DEPTH_MODE::NONE`, which prevented Fusion positional tracking and GNSS global localization from running without depth. They now work with `DEPTH_MODE::NONE` and `POSITIONAL_TRACKING_MODE::GEN_3`; such a camera contributes images and poses only, so depth, spatial mapping, object detection and body tracking in Fusion ignore it.
* Fixed `sl::Fusion::subscribe()` silently replacing an existing camera when called twice with the same serial number, which dropped the first subscription instead of reporting the mistake. It now returns `FUSION_ERROR_CODE::MEMORY_ALREADY_USED` and leaves the existing subscription in place.

### Platform

* Improved GMSL capture stability by changing the default scheduling of the capture and sensors threads of GMSL cameras with [ZED X Driver 1.5.0](/docs/development/zed-x-driver/release-notes/1-5#150) or newer: both request `SCHED_RR` priority 5 instead of `SCHED_FIFO` 99 and 50, and capture threads are no longer pinned to a CPU core. The Jetson installer lets the `zed` group use this priority from the next login; systemd services not running as root need `LimitRTPRIO=5`, and containers `--ulimit rtprio=5` or `--cap-add=SYS_NICE`, otherwise the threads run at normal priority and the SDK logs how to allow it. Older drivers keep the previous defaults, and the `ZED_SDK_CAPTURE_THREAD_*` and `ZED_SDK_SENSORS_THREAD_*` variables still override them.
* Reduced the start-up time on Jetson Thor by about 4 seconds, and on Hopper and Blackwell GPUs with the CUDA 13.0 installers (about 2.5 seconds on DGX Spark): the GPU code of the SDK is no longer compiled at the first start, after each driver update, or at every start of a container without a persistent `~/.nv` cache. With the CUDA 12.8 and 13.2 installers, Blackwell GPUs also rectify images twice as fast.
* Fixed the Jetson installers, when they install CUDA, also upgrading the JetPack 7 board support package (kernel, device trees, bootloader), and removing the system's OpenCV development packages: they now install only CUDA, TensorRT and, with JetPack 6, NVIDIA's PVA allowlist tool. They also install TensorRT when CUDA is present without it, as the NEURAL depth modes and object and body detection need it.
* Reduced the system packages installed by the JetPack 6 installers (L4T 36.4 and 36.5): libjpeg-turbo and libarchive are now bundled with the ZED SDK instead of being installed from apt, as in the other Linux installers since 5.5.
* Fixed the Linux installers upgrading system packages that are already installed (such as systemd) when they install their dependencies, and the desktop Linux installers not installing `libgomp1`. The outdated JetPack 5 ZED X drivers are removed from the Jetson installers.
* Fixed the ZED SDK CMake package (`find_package(ZED)`) configuring an application for the build machine instead of the Jetson when cross-compiling it with a CMake toolchain file.

### Samples

* Added the multi-camera positional tracking sample (C++): it tracks ZED and ZED One cameras mounted on one rigid body with the Sensors API, from live cameras, SVO files or streams listed in a YAML file, and shows the rig, its path and the shared map in 3D.
* Added the Motion Prior Recording sample (C++): it records an SVO that carries a motion prior next to the images, using the camera rotation integrated from its gyroscope as an example source. The positional tracking sample replays it on its own.
* Updated the C++ positional tracking sample to feed a motion prior to the positional tracking, from a JSON file or from an SVO that carries one, and to show how each image used it.
* Fixed the C++ Sensors API sample placing the LiDAR of its example configuration 500 m away (poses in millimeters in a meter application) and ignoring the object detection and body tracking confidence thresholds.
* Fixed the TensorRT custom detector samples (`tensorrt_yolov5-v6-v8_onnx`, `tensorrt_yolov5-v6-v8_onnx_async`) and the ZED One custom inference sample not compiling with TensorRT 10.16 (JetPack 7.2), and the OpenCV DNN custom detector sample (`opencv_dnn_yolov4`) not compiling with the ZED SDK 5 API.