Repository navigation
Release Artifacts
The links below identify the Holoscan SDK 5.0 installation channels. Check individual channels for published artifacts.
-
🐋 Docker container: tag
v5.0.0-cuda13 -
🐍 Python wheels:
pip install holoscan==5.0.0Python wheel packages
All packages below are version 5.0.0. Native component wheels target CPython 3.12+ (
abi3) on Linux (manylinux_2_39) with CUDA 13. Universal wheels are metapackages that select the corresponding native components.Package Contents holoscan Full SDK metapackage holoscan-cu13 CUDA 13 SDK metapackage holoscan-core Core metapackage holoscan-core-cu13 Core native component (CUDA 13) holoscan-vision Vision metapackage holoscan-vision-cu13 Vision native component (CUDA 13) holoscan-visualization Visualization metapackage holoscan-visualization-cu13 Visualization native component (CUDA 13) holoscan-inference Inference metapackage holoscan-inference-cu13 Inference native component (CUDA 13) For more details, see Python Bindings.
See SDK Installation prerequisites for supported platforms and system requirements.
Release Notes
New Features and Improvements
Important
Holoscan SDK 5.0 is a ground-up rewrite of the Holoscan SDK runtime and API.
Learn more about the Holoscan platform at holoscan.org.
API stability
The Stable source API core covers basic in-process graph/operator authoring, ordinary built-in scalar ports, existing explicitly named and unambiguous Python port declarations/lookup, and structured error handling in C++ and Python. These documented source contracts remain compatible across 5.x updates; deprecation and removal follow the major-release policy described in API stability. The Stable entry-point call contracts do not freeze omitted-contract trigger resolution, clock selection/admission, or automatic queue/resource derivation; these policies remain Beta. Tensor declarations, ownership, output specifications, and pools remain Beta. Plan inspection, resolved-defaults reports, typed records, and report formats remain Prototype. Existing schema version counters and compatibility epochs are retained across GA and follow their own evolution rules. Source API stability does not promise binary compatibility between SDK packages or cross-version interoperability for channels, schemas, or serialized artifacts. Follow the release-specific rebuild and deployment requirements when upgrading.
Programming model
- Callback-scoped scalar borrowing (C++ and Python) -
Input<T>::selected_sample()exposes immutable selected data and metadata without a payload copy, heap allocation, or owning read claim.sensor_io::ImageDescriptorScratchprepares bounded metadata storage during startup for Image transforms; output pixels still use a separate Tensor loan. Hosted Python Operators expose the same frozen scalar selection asOperatorPort.selected_sample(): metadata remains independently inspectable, while.datalazily materializes an owning Python projection. C++ views, references, and the Python selection facade must not escape the compute callback. Owning receive APIs remain available. - Prepared generated-schema transforms (C++) - Generated ordinary and descriptor-Tensor schemas can opt into bounded reusable native metadata with
NATIVE_BOUNDS_FILE.schema::SchemaScratch<T>andschema::DescriptorMetadataScratch<T>retain cold-prepared capacity, whileOutput<T>::emit_ref()synchronously publishes an ordinary generated schema without a by-value native-object copy. Values outside authored native bounds fail withErrorCode::kResourceExhausted; altering prepared owners or retaining a nested owner across reuse fails closed withErrorCode::kPreparedStorageInvalid. The bounds policy is a build and deployment contract rather than wire identity, so every producer and prepared consumer for a schema must use the same bounds file. Owning APIs remain available alongside prepared storage. holoscan::GraphAPI - Graph definition without anApplicationwrapper.compile()produces an immutableExecutionPlan;run_async()returns aRunSessionfor deterministic asynchronous execution and clean shutdown.- Typed Operators and ports - Operators declare strongly typed input and output ports; payloads flow as
Sample<T>with causal metadata. - Reusable Graph embedding - A compiled subgraph can be embedded into a parent graph and reused across multiple compositions.
- CUDA Graph regions - Applications can explicitly fuse an eligible fixed-shape, linear GPU region with
RegionConstraint::cuda_graph(). Runtime captures member CUDA work once after lifecycle startup and replays it on the source's planned stream while retaining ordinary Tensor readiness and publication behavior. The ordinary execution path remains available for comparison. - Automatic graph partitioning and inspection - Graphs without partition declarations use the
holoscan.partition.source_chain/1planner, which forms linear execution chains across the complete DAG, including fan-out, fan-in, diamond, and parallel edge topologies. Different partitions may execute callbacks concurrently. Applications can author exact manual anchors and request an automatic remainder, usepartition(name).include_all()for one complete composed partition, and inspect the accepted cover throughExecutionPlan::partitions(). Green Context bindings require exact named anchors; dedicated contexts are not assigned automatically. - CUDA streams follow execution partitions - By default, each active execution-partition/device pair receives one Runtime-owned CUDA compute stream, allowing independent branches to submit GPU work independently while Tensor readiness and release ordering remain automatic. Applications can select
CudaComputeStreamPolicy::kSharedProcessDeviceinCompileOptionswhen measurements favor one ordinary stream per process group and device. Separate streams permit but do not guarantee concurrent CUDA execution. - Support-thread placement (C++) - Applications can request CPU affinity for the run-session controller and, when present, the process-local Channel pump. The compiled plan records the admitted placement. A pump binding does not create a pump when the selected transport does not need one.
- CUDA Green Context manual placement (developer preview) - Applications can query a qualified CUDA 13 target, bind an exact manually authored execution partition to a driver-structured set of streaming multiprocessors, and inspect the accepted placement and diagnostics in the compiled plan. The compiler and Runtime validate the target, materialize the Green Context streams before operator execution, and preserve Tensor ordering across ordinary and Green Context streams. Automatic graph partitioning does not automatically size or assign dedicated contexts. See the CUDA Green Contexts guide.
- Lifecycle stage graph - Bounded operator lifecycle with deterministic startup, running, and shutdown stages.
- Managed shutdown signals - On Linux, blocking
run(plan)synchronously accepts SIGINT and SIGTERM through an HSDK signal domain by default; the first accepted occurrence requests cooperative stop.RunSignalPolicy::kCallerManagedprovides a blocking opt-out, while earlyManagedShutdownSignalsplusrun_async(plan, signals)provides managed asynchronous execution. Plainrun_async(plan)remains caller-managed. A second accepted occurrence delegates the actual signal under the unchanged prior policy; first-signal shutdown remains cooperative, with no forced cancellation or whole-run completion bound. A clean first accepted SIGINT returns control after cleanup with a nonzero blocking result (currently1). Managed blocking runs require an adoptable signal domain or a single live task during setup; otherwise they fail before session creation. EstablishManagedShutdownSignalsbefore creating participant threads when managed asynchronous execution is needed. An adopted domain has one binding attempt; close it after retirement and create a fresh domain for another managed run. A child created while the domain is active inherits blocked SIGINT/SIGTERM, andexec()preserves that mask. Reset the child mask withsigprocmask()beforeexec(), or usePOSIX_SPAWN_SETSIGMASK;system()andpopen()do not reset it automatically.
Temporal scheduling
- Temporal contracts -
OnEach,LatestWithin, andSkipcombinators control per-input selection policy; each operator declares aContractthat is verified at compile time. - Maximum start delay - C++
Contract::max_start_delay(...)and PythonContract.max_start_delay(...), paired withon_violation(...), bound how latecompute()may start relative to the trigger's frozen source coordinate. Entry exactly at the bound is permitted. This contract does not bound compute completion or preempt a callback. See the Temporal Contracts guide. - Deterministic time and clock identities - Monotonic clock registry and execution identities for reproducible trace correlation.
Parameters
- Typed parameter system - Operators declare typed parameters with optional defaults; parameter values are snapshot-consistent across an activation.
- Unified startup parameter authoring - Decode startup configuration with
try_decode<T>()or the throwingdecode<T>(), move the resultingPreparedParams<T>intoOperatorHandle::set_params(), and compile the graph. Use graph-ownedparams::set_params()orload_and_set_params()for atomic multi-operator configuration or snapshot restore before compilation. Semantic edits withDocument::patched()may clear the exact current-source digest; guarded saves should usedocument.digest().base_sourceasSaveOptions::expected_source_digest. - Runtime parameter generations - Parameter values can be updated at runtime between activations; a generation counter ensures consumers observe a consistent snapshot.
- Parameter configuration and persistence - Parameter sets are serializable to and from configuration files; an experimental tuner supports iterative parameter search.
- Derived Tensor pool capacity - Tensor output byte-span capacity can be derived during compilation from Parameter bounds, input bounds, and lifecycle-selected limits. Nominal-rate evidence can independently derive the edge queue depth needed for that output. The compiled plan retains both derivations and reports invalid or incomplete formulas; explicit capacity and queue depth remain available when needed. See the Tensor sizing guide.
- Parameter-derived Tensor storage (C++) - Tensor outputs can select host or device memory from compile-time parameter values. A named projector can derive a bounded output byte span when the built-in size expressions are insufficient; the compiler checks and freezes both choices before execution.
- Bounded Vision outputs (C++) - Vision operators can derive fixed output-pool bounds from their typed parameters or an input Tensor's maximum size. Invalid or overflowing bounds fail during setup or compilation.
Channels and transport
- In-process channel binding - Zero-copy operator-to-operator communication within a process via a shared temporal cache; no serialization is required.
- Bounded Tensor allocation with CUDA stream integration - Host-pinned and device
Tensorproducers with explicit device placement, CUDA stream association, and loan/commit lifetime semantics. Requires a CUDA device. - Typed Tensor port contracts -
TensorRepresentation,TensorBounds,TensorInputSpec,TensorOutputSpec, andTensorBoundaryContractdescribe Tensor representation, bounded output storage, and boundary requirements. The same input and output specs apply to descriptor-schema Tensor fields. Transfer policy belongs inTensorOutputSpec::transfer; input memory conversion belongs inTensorInputSpec::memory_conversion. See the Tensors 101 guide and Custom FlatBuffer Schemas guide. - Bounded drop-oldest queues -
QueuePolicy::kDropOldestwith depth one retains the freshest sample. Larger depths retain the newest bounded N-sample backlog in FIFO order. See the Composing a Graph guide. - Sensor payload schemas - Image and IMU schemas and Image metadata helpers are provided by
holoscan::sensor_io. Include<holoscan/sensor_io/image_metadata.hpp>and linkholoscan::sensor_io; schema types retain theirholoscan::schemanames. - Interprocess channel runtime - HoloMQ/iceoryx2-backed bounded IPC transport with zero-copy GPU memory across process boundaries.
- External channel clients - Standalone non-Operator processes connect to a running graph using only
endpoint-catalog.jsonand the stable endpoint name; client code does not require HoloMQ headers. - Explicit external subscriber close - Scalar, POD, generated-schema, raw-Tensor, and descriptor-Tensor Channel subscribers now provide a checked
close()operation for deterministic local endpoint retirement. Subscriber close discards unread local work and makes later checked operations reportkClosed; it does not publish producer EOS, close a graph port, or contribute natural-completion evidence. Publisherclose()remains the ordered EOS operation. - External producer EOS propagation - Ordered publisher EOS now has explicit end-to-end coverage through finite input-driven graph paths. Earlier accepted data and retained work drain before eligible Operator outputs close; live external subscribers observe final data before
kClosed, and a fully finite graph reaches naturalkCompletedwithoutrequest_stop(). Inputs on independent triggers remain side inputs, and admitted external-restart capacity keeps outputs open for the replacement generation. A required export subscriber must remain attached through remote EOS; disappearance after data acceptance fails terminal drain rather than satisfying EOS or retrying indefinitely. - Descriptor-Tensor schema external topics - Graph imports and exports now carry application-owned singular or multi-Tensor descriptor schemas through the endpoint catalog. Standalone non-Operator peers attach with the catalog-aware tensor-schema publisher and subscriber facades, preserving typed per-field contracts, metadata, capture coordinates, bounded backing, cross-process operation, and ordered health, data, and end-of-stream control. Tensor bytes remain in retained or imported backing rather than being serialized inline. See the External Topic Boundaries guide.
- Larger catalog inline services - Ordinary catalog-attached scalar, POD, and generated-schema endpoints now support complete fixed-inline frames through 32 KiB. After framing, the maximum application capacities are 32,744 bytes for scalar/POD and 32,704 bytes for ordinary generated schemas. Raw Tensor and descriptor-Tensor backing remains out of band and does not count toward this inline limit. See the capacity details in External Topic Boundaries and Standalone Channel Clients.
- Event-driven channel waits - Typed subscribers block on their transport event lane with
wait_and_receive_sampleinstead of pollingreceive_sample; a wait takes an absolute deadline, cancels through astd::stop_token, and reports timeout, cancellation, and end of stream as distinct outcomes. - External subscriber event-loop integration (C++) - Supported scalar, Tensor, and generated-schema subscribers expose a move-only readiness handle for Linux
poll,select, orepoll. Applications acknowledge a wake and drain nonblocking receives without a separate polling helper thread.
Graph artifacts
- Cold artifact generation - A graph-definition executable can emit its deployment bundle (
endpoint-catalog.json, FlatBuffers schema packages, and compiled plan) without starting operator lifecycle, CUDA, or transport. The--emit-artifactsCLI flag and_graph_artifactsCMake build target support this workflow. Rebuilding the target is a no-op when nothing has changed. Partition-inspection, Tensor-placement, and Parameter record keys share the segment-encodedOperatorPathgrammar without a leading slash, such aspipeline/source. - HoloMQ library (
holoscan::holomq) - Zero-copy GPU IPC publish/subscribe transport built on iceoryx2 v0.9.3 and shipped with the Holoscan SDK. Theholomq::holomqtarget remains a compatibility alias. Features include publish/subscribe queue controls, drop-oldest queues, and reusable host-memory imports that can be rebound across connection refresh.
Visualization
- Typed image and Tensor layers - Image layers of
holoscan::visualization::HolovizOpbindInput<holoscan::schema::ImageT>throughimage_layer_input(i); geometry, text, and LUT layers bindInput<holoscan::Tensor>throughtensor_layer_input(i). Both accessors use the declared layer index, with up to eight layers in any mix. Image metadata is checked against the declaredImageLayerDesc:widthandheightgive the visible size, whileplane_layoutsdescribe backing storage, including the two planes of NV12 frames. Color-space declarations must match the layer's color-space and YUV-model settings; anUNSPECIFIEDwire color space is accepted into any layer. Holoviz consumers depend onholoscan::sensor_io, whichfind_package(holoscan COMPONENTS visualization)loads. See the Visualization guide. - HolovizOp CUDA output -
HolovizOpcan render to a CUDA-backedschema::ImageToutput for another visualization, encoder, or inference operator without an intermediate display. The application binds the output to the intended CUDA device; see the source-tree CUDA sink example.
Python Bindings
The holoscan-core-cu13 distribution provides the holoscan Python package for graph authoring, compilation, execution sessions, typed ports and parameters, Tensor interchange, and external-channel clients. Tensor values support DLPack and NumPy/CUDA array interfaces. Python coverage is broad but not identical to the C++ API; module-specific and newly introduced facilities can have narrower coverage.
Python bindings for Vision, Visualization, and Inference are built as separate CUDA 13 component distributions, respectively holoscan-vision-cu13, holoscan-visualization-cu13, and holoscan-inference-cu13, each depending on the matching Core distribution. Their canonical packages are holoscan_vision, holoscan_visualization, and holoscan_inference; installed providers can also be discovered under the corresponding holoscan.<module> alias. Vision exposes registered image-processing operators, including Bayer demosaicing, through generated typed facades; Visualization and Inference expose HolovizOp and InferenceOp graph authoring through their module facades.
The holoscan metapackage selects the CUDA 13 Core, Vision, Visualization, and Inference distributions through holoscan-cu13. Install individual component distributions when only part of the SDK is needed, using the same SDK version for each component. Wheels contain Python bindings and native runtime libraries; C++ headers, CMake package files, examples, and sample datasets are provided through the other installation options.
Example catalog
- Install-tree smoke tests -
hello_world,hello_core,hello_logger,hello_tensor,hello_schema,hello_matx, andhello_ccclcheck SDK headers, CMake targets, and selected third-party dependencies in an SDK installation. - SDK example applications -
slow_fast_fusionshows a two-rate graph with temporal scheduling in C++ and Python;camera_imu_controlshows a camera/IMU fusion graph with external import and control export in both languages; andexternal_clientssuppliesexternal_client_relay,sensor_daemon, andresult_recordercompanion programs with Python client variants. See the Slow/Fast Fusion, Camera + IMU Control, and External Clients guides.
Performance
- Runtime dispatch suppresses redundant HoloMQ wake notifications and avoids polling cycles when no event-backed readiness source can make progress, reducing activation and fanout overhead. The expanded benchmark suites attribute Runtime and transport costs separately; their dated measurements are reference evidence rather than guarantees for other systems. See the Core Runtime Benchmarks and Channel Benchmarks.
- Tensor pool and catalog tensor-backing sharing reduce allocation pressure.
- Channel and HoloMQ benchmark suite (
comm_benchmark).
Breaking Changes
Warning
Holoscan SDK 5.0 is not source- or binary-compatible with Holoscan SDK 4.x. Port applications to the graph, typed-port, temporal contract, and parameter APIs described above. See Migrating from Holoscan SDK 4.x and Migrating Python from Holoscan SDK 4.x.
API and ABI changes
-
Unified startup parameter authoring - The detached
ParamOverrideSetpath was removed, includingdecode_overrides(),to_overrides(),load_overrides(),make_param_rebind_target(),ParamAdmissionContext, andCompileOptions::parameter_overrides. Decode ordinary startup configuration withtry_decode<T>(), move the resultingPreparedParams<T>intoOperatorHandle::set_params(), and call the normalcompile(graph, options). For an atomic multi-operator configuration or snapshot restore, call the graph-ownedparams::set_params()orload_and_set_params()form before compiling. No compatibility shim is provided for the removed APIs. Applying semantic edits withDocument::patched()may clear its exact current-source digest; guarded saves of an edited document should usedocument.digest().base_sourceasSaveOptions::expected_source_digest. Thedecode_params<T>()anddecode_params_or_throw<T>()names are nowtry_decode<T>()anddecode<T>(), respectively. -
Temporal maximum start delay — C++
Contract::deadline(...)and PythonContract.deadline(...)are nowmax_start_delay(...), with no compatibility aliases. Related inspection types, record fields, activation reasons, derived-term identifiers, and compiler/runtime diagnostic tokens also change. Update callers and diagnostic filters using the complete migration map. Rebuild C++ applications and regenerate artifacts: temporal records advance from version 1 to 2 and private execution plans from v8 to v9, with renamed keys and witness identities. Old artifacts have no compatibility reader. The inclusive compute-start bound and violation policies remain unchanged. -
Tensor port-spec revision: Tensor port authoring now uses
TensorRepresentation,TensorBounds,TensorInputSpec,TensorOutputSpec, andTensorBoundaryContract. ReplaceTensorPortLayoutwithTensorRepresentation; replace separateTensorAllocationBoundsandtensor_allocation()calls withTensorOutputSpec{.bounds = tensor_bounds(...), .storage = TensorOutputStorage::kRuntimePool}; replaceLogicalTensorRequirementsandLogicalTensorBoundswithTensorBoundaryContract; and use the same input and output specs for descriptor-schema Tensor fields. Transfer policy belongs inTensorOutputSpec::transfer, while input memory conversion belongs inTensorInputSpec::memory_conversion. This is an intentional source and ABI break: perform a clean rebuild, and do not mix libraries, plugins, generated artifacts, or endpoint catalogs from before and after this change. See the Tensors 101 guide, and Custom FlatBuffer Schemas guide. -
HolovizOp image layers carry
schema::ImageT: Image-kind layers ofholoscan::visualization::HolovizOpnow bindInput<holoscan::schema::ImageT>ports and check each frame'sencoding,color_space, andplane_layoutsagainst the declaredImageLayerDesc; geometry, text, and LUT layers keepInput<holoscan::Tensor>. The uniformlayer_input(i)accessor is replaced byimage_layer_input(i)andtensor_layer_input(i), both indexed by declared layer. Migrategraph.add_flow(camera->frame, viz->layer_input(0))tograph.add_flow(camera->frame, viz->image_layer_input(0)), wherecamera->frameis anOutput<schema::ImageT>published withemit_tensor(loan, descriptor, options), and overlay edges toviz->tensor_layer_input(i).ImageT::width/heightare the visible size; NV12 frames carry the schema's twoplane_layoutsrecords (Y, UV), so the backing Tensor may be a flat byte buffer. A wirecolor_spaceofUNSPECIFIEDis accepted into any layer;SRGBrequiresColorSpace::kSRGBNonlinearandREC601/REC709/REC2020on a YUV format require the matchingyuv_model.holoscan::sensor_iois now a public link and runtime dependency of every HolovizOp consumer;find_package(holoscan COMPONENTS visualization)loads it. The layer budget stayskMaxLayerPorts(8) in any kind mix. This is a source and ABI break: rebuild consumers. -
Sensor payload schemas moved to
holoscan::sensor_io:image.fbs,imu.fbs, and the Image metadata helpers moved out of the Core schema library. Sources include<holoscan/sensor_io/image_metadata.hpp>instead of<holoscan/schema/image_metadata.hpp>and linkholoscan::sensor_io. The affected symbols keep theirholoscan::schemanames, butlibholoscan_sensor_io.sodefines them instead oflibholoscan_schema.so, so objects and libraries built against the earlier Core schema library must not be mixed with this release; perform a clean source rebuild. -
Queue-policy simplification -
QueuePolicy::kLatestis removed, andkDropOldesthas numeric value 1 in Core, Channel, and HoloMQ. Rebuild all consumers; objects and libraries compiled against the previous enum must not be mixed with this release. MigratekLatesttokDropOldestwith depth one to preserve freshest-only mailbox behavior. Retaining an authored depth greater than one is an intentional semantic change: the queue preserves the newest bounded N-sample backlog in FIFO order. See the Composing a Graph guide.
Graph execution and artifacts
-
Default automatic partitioning and artifact contract - Graphs with no partition declarations now use the production source-chain planner. Multiple resulting partition owners may execute callbacks concurrently and change observable ordering across partitions. Applications that depend on the previous one-owner topology should use
partition(name).include_all()as the compatibility form or author exact anchors. The public partitioning-plan record layout requires downstream rebuilds. Embedded partition-inspection and Tensor-placement keys now use the same segment-encoded, no-leading-slashOperatorPathgrammar as Parameter records; replace leading-slash spellings such as/pipeline/sourcewithpipeline/source. -
Private execution-plan schema - The current private artifact schema is
holoscan.execution_plan.private.v9. No forwards or backwards compatibility is provided: there is no older-schema reader or translation path. Regenerate artifacts with the current SDK because any schema-identifier mismatch fails before admission. The private schema is not an ABI promise. -
Linux blocking-run signal policy:
run(plan)now requires either an adoptable compatible managed domain or exactly one live task at both process-task census reads; otherwise it fails before session creation. With no adoptable domain, successful census reads that change or are not exactly one reportRUNTIME_MANAGED_SIGNAL_DOMAIN_REQUIRED, while a census read error reportsRUNTIME_MANAGED_SIGNAL_INSTALL_FAILED; an unavailable domain or binding, or a poisoned process registry, reportsRUNTIME_MANAGED_SIGNAL_OWNER_BUSY. Adopting an explicit domain consumes its sole binding attempt, so close it after retirement and create a fresh domain before another managed run. Hosts that already own process signals should userun(plan, RunSignalPolicy::kCallerManaged)or plainrun_async(plan); hosts needing managed async behavior should establishManagedShutdownSignalsbefore creating participant threads. A child created while that domain is active inherits the blocked SIGINT/SIGTERM mask, andexec()preserves it: reset the child mask withsigprocmask()beforeexec(), or usePOSIX_SPAWN_SETSIGMASKwith an application-chosen mask.system()andpopen()do not perform that reset automatically.
Platform and toolchain requirements
- Platform requirements - Holoscan SDK 5.0 requires CUDA 13 and does not support IGX Orin or JetPack 6 and earlier. Building C++ applications against an installed SDK requires CMake 4.0 or newer. See SDK Installation prerequisites.
Advance notice: OnSpin compatibility in a future release
A future Holoscan SDK release is planned to introduce a new API for native Boolean readiness. The current proposal uses OnCondition with rising-edge and level-triggered firing. The release schedule, API name, and signatures are still subject to change. This API is not available in 5.0.
Existing supported 5.0 applications using OnSpin will remain supported when the new API is introduced. The C++ Spin API and its supported behavior will be retained, so upgrading to that release will not require a migration. You can keep your existing code as it is. Migration guidance will be provided when the new API is released.
This notice does not deprecate OnSpin in 5.0 or add compiler deprecation warnings. No removal release has been announced. The compatibility commitment covers the supported public API, not private runtime bindings. HSDK 5.0 has no public API for attaching a Spin predicate and no Python Spin authoring API. See the Spin compatibility guide for the existing C++ API, firing behavior, and binding limits.
Bug Fixes
Camera and Holoscan CLI entries refer to the separately distributed companion components.
| Issue | Component | Description |
|---|---|---|
| — | core | Fixed Runtime startup for process-local 1:1 and fanout graphs whose application-defined FlatBuffers schema contains one descriptor-backed CUDA-device Tensor field. The single-field schema now uses the same admitted binding path without requiring a dummy host Tensor field. See the Custom FlatBuffer Schemas guide. |
| — | core | Fixed typed inline receive so temporary typed-slot contention cannot drop an already accepted sample while receive staging is blocked. |
| — | core | Fixed subscriber-owner wake routing for single-process graphs with multiple execution partitions. |
| — | core | Fixed bracketed temporal windows so their anchors stop after end of stream instead of repeatedly scheduling empty windows. See the Temporal Contracts guide. |
| — | core | Fixed stale retained LatestWithin evidence retirement, including retained Tensor readiness and end-of-stream paths, so a stale sample cannot remain falsely reusable. See the Temporal Contracts guide. |
| — | core | Fixed pinned-host Tensor deallocation ordering so ordinary and CUDA Graph pipelines retain the consumer stream until asynchronous access is safe to release. |
| 6525925 | core | Clarified the external-client example procedure: artifact emission writes a deployment bundle, while the no-argument example starts the graph used for its end-to-end smoke test. |
| 6526032 | core | Updated Python Tensor test and benchmark device selection to handle deferred CUDA initialization on mixed-GPU Tegra systems. The affected runtime completion test now waits for its readiness boundary before replaying an event. |
| 6571835 | core | Corrected physical-core detection for benchmark CPU selection on platforms such as IGX Thor, allowing the documented Core Runtime benchmark preset to launch with the recommended CPU selection. |
| 6572980 | core | Stabilized the Core Runtime benchmark suite's Tensor and transport cases across the affected platforms. |
| 6717629 | core | Corrected runtime Channel readiness and contention-retry behavior that could stall GH200 transport benchmarks during publication. |
| 6568005 | visualization | Corrected Holoviz Vulkan initialization to select matching surface-maintenance and swapchain-maintenance extensions, and to reject an unsupported pairing early. |
| 6835093 | inference | Corrected Inference Python stub-generation dependencies so the Image schema module is built before it is imported during a parallel source build. |
| 6835133 | core | Corrected managed-signal setup in the running-and-stopping example. Green Context example tests now skip configurations with insufficient capacity and include shared-context coverage. |
| 6837623 | core | Corrected CUDA queue ordering in the borrowed-descriptor tests and added private IPC isolation for shared-host test runs. |
| 6800245 | camera | Corrected V4L2 setup on IGX R38.5 to skip downloading unsupported Argus headers. |
| 6840016, 6843559 | camera | Corrected standalone V4L2 build selection so unrelated SIPL and Argus components are not built by default. |
| 6927709 | cli | Corrected env-check discovery of SDK libraries installed by Debian packages under /usr/lib/<triplet>. This correction requires the updated CLI. |
| 6932398 | core | Updated hello_matx to fetch MatX when it is not found in the SDK distribution, and clarified that MatX is an example dependency rather than a Core SDK build dependency. |
| 6933604 | vision | Corrected vision_pipeline so its cpp directory can be configured directly as a standalone CMake project against an installed SDK. |
Known Limitations
- Python bindings do not yet cover every C++ capability. The separately built module bindings require their native dependencies; Inference also requires a compatible TensorRT 10 runtime in the deployment environment.
- Interprocess Channel transport and external subscriber readiness integration use Linux facilities. CUDA-backed examples and module operators require a supported CUDA 13 environment and suitable hardware.
- Camera capture quality (6744108) - On some USB camera and host configurations, V4L2 capture can intermittently report degraded frames or lose frames. Similar drops have been observed with direct V4L2 capture; the underlying capture-quality limitation remains unresolved.
Known Issues
Camera entries apply to the separately distributed Holoscan Camera module.
| Issue | Component | Description |
|---|---|---|
| — | packaging | Debian packages, Core-only installations, and builds with HOLOSCAN_BUILD_PYTHON=OFF omit holoscan/python/constructor_handle_capsule.hpp. Downstream C++/Python extensions using __holoscan_constructor_handle__ can fail to compile because this header is missing. As a workaround, vendor include/holoscan/python/ from the SDK source matching the installed release, preserve its directory structure, and add the parent include/ directory to the extension's include path. Full Python-enabled source installations already include this header. |
| 6957369 | core | In Holoscan SDK 5.0, CUDA graph pipelines whose egress consumer runs in another execution partition can intermittently terminate with RUNTIME_OPERATOR_REPLAY_MISMATCH (partition_causal_frontier_ingress). This was observed on Jetson AGX Orin when pinned-host ingress is inside the CUDA graph region and device egress is outside it. The fix is planned for 5.1. |
| — | visualization | On AGX Thor, display output at refresh rates above 144 Hz can crash the SoC display engine, including when a high-refresh-rate mode is selected through X11. Use a display refresh rate of 144 Hz or lower. If the crash occurs, physically disconnect and reconnect power to recover; a software reboot is insufficient. |
| 6801049 | camera | SIPL capture from a single mapped VB1940 camera can fail on Jetson AGX Thor. The reported single-camera failure remains under investigation separately from stereo startup timing. |
| 6843297 | core, visualization | GH200 full-suite testing has reported visualization startup and surface failures, as well as prepared CUDA-descriptor test failures. The remaining failures are under investigation. |
| 6843550 | visualization | Visualization applications on IGX Thor with an RTX PRO 5000 Blackwell dGPU can fail to find a matching CUDA/Vulkan display adapter. Build for the intended display GPU (CMAKE_CUDA_ARCHITECTURES=120 for this dGPU) and select that same GPU with CUDA_VISIBLE_DEVICES, preferably by UUID. These settings address architecture/device mismatches; some application-launch failures remain under investigation. |
| 6857163 | visualization | Visualization applications fail to launch with --display on DGX Spark. |
| 6934123 | camera | VB1940 stereo-synchronized capture on Jetson AGX Thor can exceed the default 15-second startup timeout. Set --startup-timeout-s 40 for sipl_stereo_monitor; this timeout allowed the reported capture test to pass. |
| 6938874 | vision | Holoscan 5 CUDA 13 Debian Vision packages contain dangling public CV-CUDA SONAME and linker symlinks. The tested Holoscan Vision CMake consumer and runtime workflow pass, but direct CV-CUDA linking through default library paths fails. Linking through the bundled holoscan/cvcuda directory works. |
| 6940713 | core, inference, visualization | Full-suite testing on IGX Thor iGPU has reported display-surface and cross-process CUDA Tensor retirement/stress-test failures. Related Jetson reports also include Inference example failures that have not reproduced in targeted developer runs. The remaining failure scope and configuration dependencies are under investigation. |
| 6940969 | core | Interprocess pinned-host Tensor throughput can be substantially lower than reference measurements on some x86_64 RTX A6000 configurations, with high run-to-run variability. The reported throughput reduction remains under investigation. |
| 6962655 | core | Immediately rerunning an execution plan with newly created Channel clients may fail during startup with RUNTIME_PORT_BINDING_UNAVAILABLE and an underlying wake-service kNotReady error. Fully shut down the failed session and clients before retrying; no guaranteed workaround has been validated. |
| 6962658 | core | A failed active lifecycle restart that rolls back while downstream Channel input is pending may lose a sample, even though the run later completes with a lifecycle warning. Applications requiring lossless delivery should avoid active restart during data processing and should not assume rollback preserves all in-flight data. |
| 6962940 | core | External topic inputs created with import_topic currently use a 1 ms polling fallback in sleeping wait mode, which can add receive latency. As a workaround, configure the consumer's execution partition with WakeMode::kBusyPoll to poll continuously, at the cost of increased CPU usage. Event-driven wakeups for this input path are planned for a future release. |