The ZED SDK allows you to add depth, motion sensing and spatial AI to your application. Available as a standalone installer, it includes applications, tools and sample projects with source code.
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 models show significant improvements in runtime with better point cloud density, fewer flying pixels and a closer minimum depth range: up to a third less time on Jetson Orin, Jetson Thor and DGX Spark. The INT8 8-bit precision mode now covers all 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 in CPU memory is now up to 3× 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.
Nov 16, 2026
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 measures as close to the camera. The log reports the actual precision in use: it can run in FP8 if supported (Jetson Thor, RTX 40 and newer) and faster with the same accuracy.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 vertival motion blur, lens droplets, occlusions and underexposure (up to + 32% more accurate).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).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.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 improves by -37% on Jetson Orin NX, and that 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, switch to it; other GPUs run these modes in FP16, NEURAL included where it ran in INT8 until now, and say so in the log. 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.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.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.DEPTH_MODE::ULTRA in applications that retrieve the point cloud.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.NaN) instead of too close (-inf) at close range.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.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.open() failed with ERROR_CODE::CORRUPTED_SDK_INSTALLATION with a NEURAL depth mode, as with an incomplete ZED SDK installation.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.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.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.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.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.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).RuntimeParameters::enable_fill_mode while publishing to a Fusion in the same process (CommunicationParameters::setForSharedMemory), which could be the unfilled ones.GEN_3 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 C++, C, Python and C#..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.GEN_3 tracking with PREFER_GPU by offloading more computation to the GPU (identical results).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.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.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.GEN_3 now rejects 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.getPositionalTrackingKeyframes() with GEN_3 always returning meters; positions now follow coordinate_units, so drop any manual conversion from meters.GEN_3 frame drops: occasional 200–250 ms frames with fisheye cameras, and 100+ ms pauses on loop closure with large area memory maps.GEN_3 on fisheye cameras reporting poses and keyframes up to ~1° off from the depth and point clouds.saveAreaMap() and disablePositionalTracking() hanging with GEN_3 when the area file can’t be written; they now fail and getAreaExportState() returns FILE_ERROR.GEN_3 with IMU fusion staying at the origin on simulated cameras without full-rate IMU (e.g. Isaac Sim streams or their SVO2s); tracking now falls back to visual, using per-frame orientation when available.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.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.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.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.ERROR_CODE::AI_MODEL_NOT_AVAILABLE (SENSORS_ERROR_CODE::AI_MODEL_NOT_AVAILABLE in the Sensors API), returned by open() with a NEURAL depth modes, 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.ZED_SDK_LOG_FLUSH_EVERY_MESSAGE=1 writes each one immediately, for example to keep the last messages before a crash.open() instead of making it fail once.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.open() failing with ERROR_CODE::CALIBRATION_FILE_NOT_AVAILABLE when InitParameters::optional_settings_path is a folder with no usable calibration file for the camera, since ZED SDK 5.1: 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.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.open() returning ERROR_CODE::NO_GPU_DETECTED when the NVIDIA driver is too old for the CUDA version of the ZED SDK: it now returns correctly ERROR_CODE::NVIDIA_DRIVER_OUT_OF_DATE, and the error message asks to update the driver.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.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 was always zero since ZED SDK 4.1.[2026-11-04 19:04:23 +01:00].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. For applications that need a specific color rendering, typically matching several cameras to one another or to a reference with a matrix computed from images of a color chart.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.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.sl::Camera::reboot() and to sl::Camera::reboot(sl::INPUT_TYPE::USB). Rebooting is only supported on ZED Mini cameras acquired after September 2026, with firmware v520.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.close() could block the application.nvargus-daemon) sometimes crashing when the SDK restarted a GMSL camera that had stopped sending images.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.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).open() fail or crash.open(), grab() or close() could block for minutes, or never return, when a camera stopped answering.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.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.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.open() by serial number occasionally opening another USB camera when a camera was plugged in during the open.CAMERA REBOOTING being logged on every grab() call while an USB camera restarted, it is now logged once per restart.open() on 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.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.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().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.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.getCameraSettings() returning wrong values on 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.setCameraSettings() returnedSUCCESSEXPOSURE 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.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 0AUTO_EXPOSURE_TIME_RANGE, AUTO_ANALOG_GAIN_RANGE and AUTO_DIGITAL_GAIN_RANGE settings on 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.AE_ANTIBANDING on 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).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.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 a firmware that cannot switch it, getCameraSettings() and setCameraSettings() return ERROR_CODE::INVALID_FUNCTION_PARAMETERS (the setter returned SUCCESS without switching the LED).retrieveImage() with VIEW::LEFT_NV12_UNRECTIFIED. With sl::Camera, RIGHT_NV12_UNRECTIFIED returned SUCCESS without filling the Mat on inputs without a native NV12 buffer. USB cameras, SVO, stream now return ERROR_CODE::INVALID_FUNCTION_CALL, or ERROR_CODE::FAILURE when the buffer of this frame is missing.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.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.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.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).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.InitParameters::camera_disable_self_calib is set, which is recommended for reproducible simulation results.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.open() 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.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.grab() was called or not.setSVOPosition() sometimes landing on the wrong frame: on SVO2 files, seeking a few frames ahead, for example when stepping through a file frame by frame, returned wrong images (corrupted images with H.264), and on Jetson with SVO files recorded before the SVO2 format.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.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.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.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.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.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.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).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.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.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).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.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.getPosition() stays POSITIONAL_TRACKING_STATE::OFF until enablePositionalTracking() is called.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.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.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.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.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, ...).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.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.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.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.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.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.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.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.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.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.~/.nv cache. With the CUDA 12.8 and 13.2 installers, Blackwell GPUs also rectify images twice as fast.libgomp1. The outdated JetPack 5 ZED X drivers are removed from the Jetson installers.find_package(ZED)) configuring an application for the build machine instead of the Jetson when cross-compiling it with a CMake toolchain file.pyzed required NumPy 2, which pip could not install in place of the system's, and which would have broken the system's OpenCV and SciPy. pyzed now runs with the NumPy 1.x releases its Python version supports (1.25 and later with Python 3.12), and no longer requires Cython at run time.Camera.get_init_parameters() and the other get_*_parameters() methods of sl.Camera returning only some of the parameters, the others at their default values: depth_precision and depth_compute_device always read FP16 and AUTO whatever the precision and the processor in use, and imu_sampling_rate, sensors_required or open_timeout_sec, for example, read their defaults.Mat.get_memory_type() and Mat.get_data() raising ValueError: 6 is not a valid MEM on Jetson for a Mat allocated with MEM.BOTH, or retrieved with MEM.BOTH into an empty Mat: it reports MEM.BOTH.SensorDeviceIdentifier objects of the same sensor not comparing equal, so they could not index the dictionaries returned by the batched Sensors methods, and Sensors.add() dropping the sensor_name of the identifier it fills.POSE_AXIS to the type stubs (sl.pyi) and to the Python API reference, where it was missing.SL_MAT_TYPE_NV12, the type of the SL_VIEW_LEFT_NV12 and SL_VIEW_RIGHT_NV12 images.MAT_TYPE.MAT_NV12, the type of the VIEW.LEFT_NV12 and VIEW.RIGHT_NV12 images.NEURAL_LIGHT, NEURAL_PLUS and NEURAL_MAX depth modes, and on Jetson, the processor that runs the NEURAL_LIGHT depth (GPU, DLA or PVA) to the depth settings (experimental). A processor that cannot be used there is greyed out.NEURAL depth model was optimized again after an SDK upgrade or a GPU change. The optimization progress now shows whenever an optimization is needed.-a / --all command-line option to open every connected camera at launch, and the --resolution <resolution> and --fps <frame_rate> options to set the capture format of every camera opened during the session: a camera that does not support the resolution opens at its default one, an unsupported frame rate is replaced by the closest supported one, and a format given to one camera with -c / --camera takes precedence.--check command-line option: like -a, but also confirms each available camera delivers images, catching a GMSL camera left unable to stream after an application crash. Exits non-zero on failure, for use in scripts.-o (record) and -s (stream): they hung with GMSL cameras without recording or sending any image, and with -i or --sn they opened the GUI once the recording or the streaming ended, and aborted without a display after saving the SVO.--download_calibration exiting with code 0 when the calibration could not be written to the camera.-nrlo*, -ais, -aio, -aid) reporting why a download or an optimization failed, such as no internet access, a models folder the user cannot write to, or a TensorRT version this ZED SDK was not built for, where they only suggested to run again with -v. The warnings and errors of the ZED SDK now show without -v.-ingest-motion-prior option, which records the motion prior of a JSON file (the format of the positional tracking sample) into a copy of an SVO2 file so the positional tracking sample replays it, and added the motion prior to -export-to-mcap.-encrypt and -decrypt ending with exit code 0 when they failed, for example with a wrong key, and -ingest-motion-prior aborting on Jetson instead of returning its error when it refused the input (a SVO that already carries a motion prior, a SVO before SVO2, an unreadable motion prior file). -h now prints the help, which printed nothing.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.sl::TIMESTAMP_CLOCK and the sl::setTimestampClock(), sl::getTimestampClock(), sl::getCurrentTimeStamp(), sl::setMaxSystemClockStepMs() and sl::getMaxSystemClockStepMs() functions, already documented for Python and C#.Camera::open() and CameraOne::open() documentation (C++ and Python), which said that an already opened camera is closed first: open() returns ERROR_CODE::INVALID_FUNCTION_CALL instead, so call close() before opening it again.Before you upgrade, check these changes:
POSITIONAL_TRACKING_MODE::GEN_3 in this version can’t be loaded by older versions.For older releases and changelog, see the ZED SDK release archive.