AivexaNewsSearch
AI news for builders and product teamsChecked every hour

Make a Robot Arm Feel Weightless with NVIDIA Holoscan 5

Collected Nov 9, 2026

NVIDIA published a developer tutorial showing how to build a hand-guideable "weightless" robot arm on Holoscan 5, the SDK release that added robotic control alongside its sensor-processing stack. The walkthrough targets the Seeed Studio reBot Arm B601-DM and has been tested on Jetson Orin Nano, Jetson Thor and x86 machines running Ubuntu 24.04. Complete Python and C++ implementations are included, each built from the same three custom operators.

The goal is gravity compensation: the motors supply just enough torque to hold the arm up, so a person can push it around by hand. That requires solving inverse dynamics continuously from a model of every link's dimensions, masses and moments of inertia, at low latency and low jitter. The tutorial treats it as a proof of life for both the robot model and the runtime executing the math, since errors in joint axes, offsets or mass properties show up immediately as the arm sagging or pushing upward as it moves.

The SDK's central concepts are operators and graphs. The first operator is a joint-state source driven by a clock contract that requests a tick every 2.5 ms, or 400 Hz; each compute() call reads all seven motors and emits their state. The second receives that state whenever it arrives, maps six arm angles into a URDF model, checks limits, and obtains gravity torques from Pinocchio's Recursive Newton-Euler Algorithm solver. Gains, torque scaling and joint direction are exposed as operator parameters, with stiffness (kp) defaulting to 1.5 and damping (kd) to 1.0. Those torques become feedforward alongside position, velocity, stiffness and damping in the motor commands. The third operator passes each command to a helper that rejects expired, out-of-order or out-of-range commands before sending the batch, and a watchdog disables the motors and stops the graph if no batch completes within 100 ms.

Pinocchio is a well-known open-source rigid-body dynamics library, and RNEA is its standard algorithm for computing joint torques from a given position, velocity and acceleration. The motorbridge library handles reading feedback and sending commands to the arm's motors. The reBot Arm matters here because it uses quasi-direct-drive actuators rather than the highly geared hobby servos common on low-cost arms; those servos are suited only to positional control, while QDD actuators offer the torque bandwidth needed for haptic and compliant behavior.

Performance comes from how the graph is arranged. All three operators sit in one partition, meaning their callbacks run serially on a single runtime-owned thread, which removes thread handoffs between reading state, computing torque and sending commands. The connections use depth-one queues with a drop-oldest policy so stale samples never accumulate. The source sets the pace and the downstream operators follow incoming data. Before the motors are enabled, Holoscan compiles the description into an inspectable execution plan and raises an error if compilation fails; motor and model initialization happen only after that check.

The tutorial profiles the unmodified application with Nsight Systems using Holoscan's built-in NVTX annotations, requiring no tracing decorators or custom timing code. The authors compared pinned and unpinned configurations across more than a million cycles per run, excluding the first ten seconds, and measured latency from entry into the first operator to entry into the last, excluding motor-command transmission. Pinning the control partition to a dedicated CPU core, with helper and profiler threads moved elsewhere and a temporary Linux cgroup reserving both physical cores including SMT siblings, reduced observed p99.99 latency by roughly 5x for C++ and 9.6x for Python. The cgroup setup needs no kernel rebuild, boot-parameter changes or reboot, though interrupts, timers and some kernel threads can still run on those cores.

The gap between the two languages is instructive. Both call Pinocchio's C++ solver, but the Python version adds interpreter execution, object allocation and GIL coordination around both Pinocchio and the Holoscan runtime, which matters when the latency budget is measured in microseconds. C++ gives finer control over allocations and syscalls in the critical path, though the example still allocates memory and is not a zero-syscall pipeline. This suggests teams running hard real-time CPU loops should default to C++, while Python stays practical for composing pipelines whose heavy elements, such as perception and inference, are implemented in CUDA where workloads take milliseconds or tens of milliseconds.

A second Python example in the repository extends the loop with kinematics and impedance control as reusable operators, letting an external source such as a learned policy inject a goal position and orientation while the arm stays compliant to touch. From there the tutorial points toward hand-guided teaching, teleoperation and manipulation, and toward adding perception through Holoscan's vision module and components from NVIDIA Isaac ROS, which supplies reusable operators and reference applications including GR00T inference.

Why it matters: developers building torque-controlled robots get a worked, measurable reference for a hard latency problem, including concrete numbers on what CPU pinning buys in each language. Teams weighing Holoscan against a custom control runtime can use the published comparison and the inspectable execution plan to judge fit before committing hardware time. The main inference to draw is that runtime discipline, not just solver choice, dominates stability once feedback rates climb into the hundreds of hertz.

Read at NVIDIA Developer Blog

Based on reporting from the original publisher. Visit the source for full context and later updates.

Publisher excerpt

Picture guiding a robot arm by hand while its motors supply just enough torque to support its weight and keep the robot upright. This simple interaction, a...