Holoscan SDK at a Glance

Holoscan helps you turn data from cameras, sensors, and other devices into a useful result: an image on a display, an inference, a fused measurement, or a decision passed to another part of an application.

The important idea is simple: you describe how pieces of work are connected, then the SDK prepares and runs that pipeline for you. You can start with a small application and add more operators, devices, models, or processes as the problem grows.

If you need to connect a camera, add your own processing or improve performance, RidgeRun can work with your team on the application. Contact RidgeRun to see how we can help, or read How Can RidgeRun Help? for more details.

Start with an outcome

If you need to capture a frame, transform it, run inference, and display the result, begin with the Vision Pipeline Example. If you need to write the processing step yourself, continue to Writing a Minimal Operator.

What Can You Build?

Holoscan is useful when an application must move data through several processing steps while keeping timing, data representation, and device integration explicit.

Common workflows include:

receiving frames from a camera and preparing them for a model;
transforming or filtering sensor measurements;
combining streams that arrive at different rates;
running inference and forwarding its results to visualization or control;
sharing selected data between processes; and
measuring or tuning a complete sensor-to-result path.

The SDK does not decide what your application means by “ready,” “fresh,” or “complete.” You express those choices in the graph and in the operators that process its data. The Core Concepts pages introduce the vocabulary before the user guides ask you to configure it.

The Pipeline Mental Model

Before looking at API names, think of an HSDK application as a directed pipeline:

sensor or input -> processing -> inference or decision -> result
                                                               |
                                                display, storage, or control

An operator performs one unit of work. A port is a named input or output on that operator. A sample is one piece of data moving through the graph, together with the metadata needed to interpret it. A graph connects the operators and describes the pipeline.

These ideas are introduced in more detail in Application, Graph, and Operator Anatomy and Ports, Samples, and Payload Types.

From Application Description to Running Pipeline

The normal path has three stages:

Stage	What you do	What to look for
Compose	Create operators and connect compatible ports.	The graph expresses the data path and the timing choices your application needs.
Compile	Ask the SDK to check and prepare the graph.	Type mismatches, missing timing information, and unsupported combinations are found before the run starts.
Run	Start the prepared graph and observe its result.	The application decides how to stop, wait for completion, and handle failures.

A plan is the prepared form of a graph. A plan's ok() result tells you whether compilation produced an accepted plan. An asynchronous run returns a RunSession, which lets the application request a cooperative stop, wait() for cleanup, and inspect the termination() outcome.

The following fragment shows the shape of that flow without hiding the user decision behind a large application listing:

// The operators have already been created and connected.
const holoscan::ExecutionPlan plan = holoscan::compile(graph);
if (!plan.ok()) {
  // Inspect the compile diagnostics before starting the application.
  return 1;
}

auto session = holoscan::run_async(plan);
session.wait();

if (session.termination() == holoscan::RunTermination::kFailed) {
  // Read structured diagnostics and report the failure.
  return 2;
}

The exact operator and run APIs are taught in Writing a Minimal Operator and Running and Stopping.

Choose Your Starting Point

Your goal	Start here
I want to install the SDK and run something quickly.	Build, Run, and Validate
I want to understand the basic graph and operator model.	Core Concepts: Operators and Graphs
I want to create my own operator.	Writing a Minimal Operator
I need to represent images, IMU data, or other sensor measurements.	Sensor Payloads and Schemas
I need to choose a camera integration path.	Holoscan Camera Overview
I want to compare complete applications.	Examples
I need help developing, integrating or optimizing my application.	How Can RidgeRun Help?

Use the Official NVIDIA Documentation

This wiki explains the selected development path and adds RidgeRun-specific integration guidance. The official NVIDIA Holoscan SDK documentation remains the authoritative reference for the complete SDK user guide, API details, installation options, and broader supported workflows.

Use the official Getting Started sequence when you want NVIDIA's installation-to-first-application route. Use this wiki when you want a guided path through the concepts, examples, module choices, and integration decisions covered by this project.

Continue Learning

Continue learning

Build, Run, and Validate for installation and first execution.
Ports, Samples, and Payload Types for the data contract between operators.
Tensor Contracts and Memory Types for image and array representation.
Managed Run Control Example for stopping, completion, and failure outcomes.

Source reference

❯