ZED SDK 5.6
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_3in 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 defaultDEPTH_PRECISION::FP16it 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::INT8takes 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::NEURALandNEURAL_PLUSdepth 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 (especiallyNEURAL_PLUS) are now able to perceive objects much closer to the camera (down to 3 cm close withNEURALon 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,ULTRAandPERFORMANCE, for the same depth: computing it takes half the time withQUALITYand about 40% less withULTRAandPERFORMANCEon Jetson Orin, and is 2.5 to 3.8 times faster withQUALITY, 1.8 to 2.3 times withULTRAand 1.8 to 2 times withPERFORMANCE. WithRuntimeParameters::enable_fill_mode, filling the depth also takes about half the time. Each camera also uses about 60 MB less GPU memory withQUALITYand 90 MB less withULTRAat 1080p (system memory on Jetson). - Improved the speed of
DEPTH_MODE::NEURAL_LIGHTon 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_precisionset toDEPTH_PRECISION::INT8) toDEPTH_MODE::NEURAL_LIGHTandNEURAL_PLUSon Jetson Orin, Jetson Thor, and RTX 30, RTX 40 and RTX 50 series GPUs. INT8 trades some accuracy for speed: theNEURAL_LIGHTdepth network takes up to 37% less time on Jetson Orin NX, and those ofNEURALandNEURAL_PLUS5 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_LIGHTuses FP8, which brings its depth a third closer to the model’s full-precision result in the same time. Applications that already requested INT8 withNEURAL_LIGHTorNEURAL_PLUS, which ran in FP16 until now, now get INT8. On other GPUs, these modes run in FP16 and the log says so; this includesNEURAL, which ran in INT8 there until now. Optimize the models ahead of time withsl::AI_MODELS::NEURAL_DEPTH_INT8or the newsl::AI_MODELS::NEURAL_LIGHT_DEPTH_INT8andNEURAL_PLUS_DEPTH_INT8(C++, C, Python and C# APIs), or ZED Diagnostic’s-nrlo_light_int8,-nrlo_int8and-nrlo_plus_int8. - Reduced the flying pixels of the
NEURAL_LIGHT,NEURALandNEURAL_PLUSdepth 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 runDEPTH_MODE::NEURAL_LIGHTon an accelerator of the Jetson instead of the GPU, which leaves the GPU to the application:sl::DEPTH_COMPUTE_DEVICE::DLAon Jetson AGX Orin and Orin NX with JetPack 6,sl::DEPTH_COMPUTE_DEVICE::PVAon Jetson AGX Orin, Orin NX (JetPack 6 and 7.2) and Thor. When the accelerator cannot be used, the depth runs on the GPU andopen()returnsERROR_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_LIGHTandNEURAL): 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::ULTRAin 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::NEURALandNEURAL_LIGHTreturning 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()orsl::optimizeAIModel()in the same application:open()failed withERROR_CODE::CORRUPTED_SDK_INSTALLATIONand the application then crashed (access violation innvinfer_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 withERROR_CODE::CORRUPTED_SDK_INSTALLATIONwith a NEURAL depth mode, as with an incomplete ZED SDK installation. - Fixed
InitParameters::allow_depth_cuda_graphwith several cameras in one application: when the recording of the depth computation of a camera failed, most often as the cameras started together, itsgrab()returnedERROR_CODE::CUDA_ERRORand the camera stopped. The recording is now retried on the next frames, then the regular computation is used. - Fixed
Camera::retrieveVoxelMeasureinREFERENCE_FRAME::WORLDmeasuring distances from the world origin instead of the camera: it returned fewer voxels as the camera moved away from its starting point, failed beyondInitParameters::depth_maximum_distance, and sized the depth-adaptive voxels wrongly. Its first call afteropen()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::NORMALSwithDEPTH_MODE::QUALITYandPERFORMANCE, 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 firstMEASURE::NORMALS_RIGHTretrieved withDEPTH_MODE::ULTRAcontained no valid normal, andVIEW::NORMALS_RIGHT_GRAYshowed the shading of the left normals. - Fixed the confidence map of
DEPTH_MODE::ULTRA, theMEASURE::NORMALSofDEPTH_MODE::QUALITYandPERFORMANCE, and the voxel centroids ofCamera::retrieveVoxelMeasurevarying slightly between two runs on the same input: they are now the same at each run. - Fixed the temporal filtering of
RuntimeParameters::enable_fill_modewithDEPTH_MODE::PERFORMANCE,QUALITYandULTRA, 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_modesometimes being the unfilled ones while publishing to a Fusion in the same process (CommunicationParameters::setForSharedMemory).
SLAM
- Added motion prior fusion to
GEN_3positional tracking: it can now fuse motion from your own source (wheel odometry, external VIO, GNSS) throughCamera::ingestMotionPrior(), keeping it accurate in fast motion, low texture or occluded scenes. Fusion status is reported inPositionalTrackingStatus::relative_pose_fusion_status. Available in the C++, C, Python and C# APIs. - Improved
POSITIONAL_TRACKING_MODE::GEN_3accuracy 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_3tracking withPREFER_GPUby offloading more computation to the GPU (identical results). - Reduced
POSITIONAL_TRACKING_MODE::GEN_3processing time with a single camera whenPositionalTrackingParameters::enable_area_memoryis disabled, so fewer frames are dropped at 30 and 60 Hz, especially on Jetson. - Added the experimental
PREFER_ACCELERATORScompute preference:GEN_3tracking 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 toAUTO. - Changed the
POSITIONAL_TRACKING_MODE::GEN_3area file format to store the map of several cameras tracked together (MULTI_SENSOR_TRACKING_MODE::SINGLE_BODYin 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 timesaveAreaMap()is called, so keep a copy of the original if an older SDK still needs it. - Changed
GEN_3to reject area files whenenable_area_memoryis off:enablePositionalTracking()returnsINVALID_AREA_FILEifarea_file_pathis set, andsaveAreaMap()returnsSPATIAL_MEMORY_DISABLED, as withGEN_1. - Fixed
getPositionalTrackingKeyframes()withGEN_3always returning meters; positions now followcoordinate_units, so drop any manual conversion from meters. - Fixed
GEN_3frame drops: occasional 200–250 ms frames with fisheye cameras, and 100+ ms pauses on loop closure with large area memory maps. - Fixed
GEN_3on fisheye cameras reporting poses and keyframes up to ~1° off from the depth and point clouds. - Fixed
saveAreaMap()anddisablePositionalTracking()hanging withGEN_3when the area file can’t be written; they now fail andgetAreaExportState()returnsFILE_ERROR. - Fixed a partially readable area file loading silently and never relocalizing: it now logs a warning.
- Fixed
GEN_3with 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::retrieveImageandCamera::retrieveMeasureinto 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 asl::Matallocated 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=1restores 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=1restores 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), setZED_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_AVAILABLEin the Sensors API), returned byopen()with a NEURAL depth mode,enableObjectDetection()andenableBodyTracking()when the AI model is missing and cannot be downloaded, for example without internet access. These calls returnedERROR_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 returnsERROR_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=1writes 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 asSN<serial>.conf.bakwhen a valid calibration replaces it, and kept in place otherwise. - Fixed
open()failing withERROR_CODE::CALIBRATION_FILE_NOT_AVAILABLE(since ZED SDK 5.1) whenInitParameters::optional_settings_pathis 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()returningERROR_CODE::NO_GPU_DETECTEDwhen the NVIDIA driver is too old for the CUDA version of the ZED SDK: it now correctly returnsERROR_CODE::NVIDIA_DRIVER_OUT_OF_DATE, and the error message asks the user to update the driver. - Fixed
Camera::retrieveImageandCamera::retrieveMeasurewithsl::MEM::BOTHinto an emptysl::Matreturning aMatthat 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_MATRIXto 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_rangeandimu_sampling_rateto 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), andIMU_SAMPLING_RATE::HZ_400doubles the gyroscope rate for applications that need more motion samples between frames. The defaults are unchanged (±12 g, ±1000 deg/s, 200 Hz), andgetCameraInformation().sensors_configurationreports 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::OFFopens 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 tosl::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_fpsdelaying 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 returnsERROR_CODE::CAMERA_NOT_DETECTEDand logs the disconnection, orERROR_CODE::CAMERA_REBOOTINGwhile the camera restarts, assl::Cameradoes. - Fixed restarting
zed_x_daemon(for example withsudo 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()orclose()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_recoveryoff), thegrab()that recovered the camera returned the image captured before the failure; it now returns a new image, orERROR_CODE::CAMERA_REBOOTINGif none arrives within 2 seconds. While the camera was disconnected,getSensorsData()withTIME_REFERENCE::CURRENTreturned the last IMU sample, then blocked until the camera was back; it now returnsERROR_CODE::CAMERA_NOT_DETECTED. - Fixed
open()on Windows failing to open an available USB camera: the defaultopen()tried a camera already in use, then failed afterInitParameters::open_timeout_sec. A camera in use is now listed assl::CAMERA_STATE::NOT_AVAILABLE, and requesting it by id or serial number returnsERROR_CODE::CANNOT_START_CAMERA_STREAMright away. - Fixed
open()leaving the camera reported as opened after failing on corrupted first frames (USB and GMSL), so every retry returnedERROR_CODE::INVALID_FUNCTION_CALLuntilclose(), andopen()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 REBOOTINGbeing logged on everygrab()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 fromgetSensorsData()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 byenablePositionalTracking()with IMU fusion, which then tracks from the images only. WithFLIP_MODE::AUTO, such a camera keeps its images unflipped; setFLIP_MODE::ONorOFFinstead. - Fixed the image health checks:
HealthStatus::low_image_quality(andlow_depth_reliabilitywith 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 sporadicERROR_CODE::CORRUPTED_FRAMEreturns fromgrab(). - Fixed
getCameraInformation().sensors_configurationon 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()returningSUCCESSfor a setting that was not applied, onsl::Camera,sl::CameraOneandsl::Sensors, and made its errors specific:INVALID_FUNCTION_PARAMETERSfor a setting the camera does not support or an AEC/AGC region outside the image,INVALID_FUNCTION_CALLon SVO playback,CAMERA_NOT_INITIALIZEDwhen the camera or stream is gone, andFAILUREwhen the camera refused the value. On a stream input,SUCCESSmeans 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_TEMPERATUREcould read back an impossible value such as -1700, andEXPOSUREandGAINread 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()returnedSUCCESS. - Fixed a manual
EXPOSUREorGAINbeing ignored on USB cameras when set back to its previous value after the automatic exposure had run (AEC_AGCset to 1, orEXPOSUREset 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:EXPOSUREorGAINset to -1 afterAEC_AGCwas set to 0 or after a manualGAIN, andWHITEBALANCE_TEMPERATUREset to -1 afterWHITEBALANCE_AUTOwas set to 0. - Fixed the
AUTO_EXPOSURE_TIME_RANGE,AUTO_ANALOG_GAIN_RANGEandAUTO_DIGITAL_GAIN_RANGEsettings 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 bygetCameraSettings()and was lost whenAEC_AGCwas switched off and on again, and a bound of -1 onAUTO_EXPOSURE_TIME_RANGEdid not select the camera limit as documented, so the range was not applied. - Fixed
AE_ANTIBANDINGon the ZED X family:getCameraSettings()always returned -1 instead of the mode in use, and setting it toVIDEO_SETTINGS_VALUE_AUTO(-1) kept the previous mode instead of restoring the default. The documented default is corrected toAUTO, the mode cameras have always opened in (it saidOFF). - Fixed
sl::CameraOnekeeping the camera settings of the previous session afterclose()andopen():setCameraSettings()ignored a value already set before closing, which left the camera on its default, andgetCameraSettings()could report that old value. - Fixed
getCameraSettings()always returningERROR_CODE::FAILUREforLED_STATUS: it now returns the LED state on USB cameras. On cameras without a status LED, or with firmware that cannot switch it,getCameraSettings()andsetCameraSettings()returnERROR_CODE::INVALID_FUNCTION_PARAMETERS(the setter returnedSUCCESSwithout switching the LED). - Fixed
retrieveImage()withVIEW::LEFT_NV12_UNRECTIFIEDandRIGHT_NV12_UNRECTIFIED: withsl::Camera, they returnedSUCCESSwithout filling theMaton inputs without a native NV12 buffer. USB cameras, SVO files and streams now returnERROR_CODE::INVALID_FUNCTION_CALL, orERROR_CODE::FAILUREwhen the buffer of this frame is missing.
Zero-Copy Capture (Jetson Only)
- Changed the experimental zero-GPU rectification mode (
ZED_SDK_EXPERIMENTAL_RECTIFICATION_BACKENDset toVICorCPU) to remap a frame only whenretrieveImage(RawBuffer&, true)first asks for its rectified pair (about 11 ms at 1920x1200 on Jetson AGX Orin withVIC):grab()no longer waits for it, and frames that are not retrieved cost nothing. - Fixed
retrieveImage(RawBuffer&, true)called from another thread whilegrab()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 forgrab(), asretrieveMeasure()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 withDEPTH_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_LIGHTgoes from 180 to 277 FPS on an RTX 3090. To restore the previous behavior, setZED_SDK_SVO_HOST_DECODE=1(desktop) orZED_SDK_SVO_V4L2_DECODER=1(Thor). - Fixed
SVO_COMPRESSION_MODE::H265_LOSSLESSandH264_LOSSLESSrecordings 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 withH265_LOSSLESSand 30 times withH264_LOSSLESS(about 75 MB/s withH265_LOSSLESSfor a ZED X Mini at HD1200 and 30 FPS).SVO_COMPRESSION_MODE::LOSSLESSstays 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_calibis 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 returnsERROR_CODE::INVALID_FUNCTION_PARAMETERSfor the others instead ofSUCCESS, andgetCameraSettings()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 missingInitParameters::svo_decryption_keyeven 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()withoutdisableStreaming()), 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_modereturning the frame before the one sought bysetSVOPosition(), showing the frame before the one paused on withpauseSVOReading(), 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::H264orH264_LOSSLESS):grab()returnedERROR_CODE::END_OF_SVOFILE_REACHEDone 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()withTIME_REFERENCE::CURRENTon a stream input: whilegrab()ran, it returnedSUCCESSwith empty IMU data about half of the time, and otherwise an older sample, which it also took away from the samplesgrab()pairs with the images. It now returns the latest IMU sample received, orERROR_CODE::SENSORS_NOT_AVAILABLEbefore 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, andPOSITIONAL_TRACKING_MODE::GEN_1withenable_imu_fusionreturnedERROR_CODE::SENSORS_DATA_REQUIRED. These files, including those already recorded, now play back the IMU of each frame. Recordings of a stream also keep itsSensorsConfiguration::camera_imu_transforminstead 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_inputset 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, andgetTimestamp(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 dqthreadbeing 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_BODYmulti-sensor mode: ZED and ZED One cameras on one rigid body are tracked together in a shared map. RequiresGEN_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, likeCamera::ingestMotionPrior(), applied to the rig inSINGLE_BODYmode or to the named ZED camera otherwise, withsensor_transformgiven in theBASELINKframe (C++ and Python). - Added
Sensors::retrieveVoxelMeasure(), the point cloud of a ZED camera decimated on a voxel grid asCamera::retrieveVoxelMeasure()returns it, inRuntimeSensorsParameters::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_transformsis set), soWORLDmatchesBASELINKat start and a ZED One moves with the tracked cameras;getPosition()withBASELINKreturns per-frame motion inBASELINKaxes, andresetPositionalTracking()takes aBASELINKpose. - Changed object detection and body tracking to no longer turn on positional tracking:
getPosition()staysPOSITIONAL_TRACKING_STATE::OFFuntilenablePositionalTracking()is called. - Fixed
enableObjectDetection()crashing whensensors_idsheld a ZED One, a LiDAR ordefaultSensorDeviceIdentifier(): 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_unitsnot being converted:depth_maximum_distance = 10withUNIT::METERbecame a 10 mm limit under the defaultUNIT::MILLIMETER. Sensor poses are expressed inInitSensorsParameters::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, mostLIDAR_MEASUREpoint clouds (XYZ_INTENSITY,XYZ_RANGE, …) left in the sensor frame, andretrieveObjects()andretrieveBodies()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 inclose(), 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_filenamesall 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 assl::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 returningSUCCESSwhen no sensor produced data or when the requested sensor failed, andresetPositionalTracking(), the region of interest functions,ingestDataIntoSVO()andretrieveSVOData()returningSUCCESSinstead 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 nextprocess(), andSENSORS_SYNC_POLICY::DROP_STALEreporting the most recent data as stale while a stalled sensor was reported fresh. - Fixed
isPositionalTrackingEnabled()returningtruewith no tracked sensor,getCameraInformation()of a ZED One lacking its calibration,getRecordingStatus()and the batchedgetTimestamp()andgetCurrentFPS()leaving out LiDARs, and theverbose,maximum_working_resolution,sdk_gpu_idandsdk_cuda_ctxsettings ofInitSensorsParametersbeing ignored. - Fixed calls given only sensor ids that are not added, or only sensors of a type the call does not take, returning
SUCCESSwithout doing anything: the batched getters and retrieve calls,getPosition(),resetPositionalTracking(),enableRecording()andenableStreaming()now returnINVALID_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()andingestCustomMaskObjects()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_fittingonBODY_18andBODY_34sometimes 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 withERROR_CODE::INVALID_FUNCTION_CALLwhen the camera was opened withDEPTH_MODE::NONE, which prevented Fusion positional tracking and GNSS global localization from running without depth. They now work withDEPTH_MODE::NONEandPOSITIONAL_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 returnsFUSION_ERROR_CODE::MEMORY_ALREADY_USEDand 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_RRpriority 5 instead ofSCHED_FIFO99 and 50, and capture threads are no longer pinned to a CPU core. The Jetson installer lets thezedgroup use this priority from the next login; systemd services not running as root needLimitRTPRIO=5, and containers--ulimit rtprio=5or--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 theZED_SDK_CAPTURE_THREAD_*andZED_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
~/.nvcache. 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.

