Skip to navigation

ZED SDK 5.6

Release notes of the ZED SDK 5.6.x series
Open in ClaudeOpen in ChatGPT

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.

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.

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.

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 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 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.