[ overview ]
Depth as software on the chip you already ship.
Hammerhead ARM runs NODAR stereo depth on standard ARM Cortex-A CPU cores, as a library alongside your perception software.
It runs today on NXP i.MX 95, NVIDIA Orin (CPU only) and Raspberry Pi, and targets any ARM Cortex-A SoC running Linux.
Every depth point is an image pixel, so AI detections map straight into 3D, with no LiDAR-camera calibration or synchronization.
Hammerhead ARM point cloud on HD1K, a public dataset recorded on city streets: about 120k points per frame, with 3D boxes from AI detections.
[ at a glance ]
Frame after frame, a 3D map.
Each Hammerhead ARM frame adds about 120k points in LiDAR-like rows. Aligned over the drive with KISS-ICP, an open-source point cloud odometry method, the frames stack into a 3D map of the street.
Accumulated point cloud from Hammerhead ARM on HD1K, aligned with KISS-ICP and colored by height for visibility
NXP i.MX 95 replaying HD1K: depth (top) from the camera images (bottom), computed on the six CPU cores while the GPU and NPU sit at 0%.
61.8 fps
One Cortex-A78 core, 1280 x 720, 64 rows
1.2% median depth error
After NODAR calibration
~200 MB
Peak memory on a Raspberry Pi 3A+
[ where it fits ]
A depth layer in your stack.
No new hardware under it.
Hammerhead ARM sits between your stereo cameras and your perception software, and runs on the processor already in your product.
Your product
The robot, car, train or vessel that needs to see in 3D
Hammerhead ARM
LiDAR-class depth from stereo cameras.
Your ARM SoC
NXP i.MX 95, NVIDIA Orin, Raspberry Pi. CPU only. GPU and NPU free.
Radar (optional)
Any automotive radar, fused with stereo depth.
= LiDAR-class 3D without the LiDAR
[ accuracy ]
CPU depth that tracks the GPU.
Scene for scene, on 36 driving scenes.
Hammerhead ARM’s median relative depth error is 1.2% on CPU alone, against 1.0% for GPU Hammerhead, and it stays close to the GPU result in every scene.
Metric
Hammerhead ARM (CPU)
Hammerhead (GPU)
Depth error under 10 m
0.19 m
0.10 m
Median relative depth error
1.2%
1.0%
Valid-pixel density
87.7%
82.5%
Reference depth comes from FoundationStereo (NVIDIA, CVPR 2025), not LiDAR, so numbers are deviations from that reference, and the reference itself can be wrong, for example with raindrops on the windshield. HD1K uses a 30 cm baseline. Depth error scales with 1/baseline, so a 1.2 m baseline gives a quarter of the error. HD1K images are 8-bit grayscale, and 12- or 16-bit raw camera input improves stereo results.
[ on the road ]
Camera in, depth out.
1,083 frames, 36 scenes, CPU only.
Top: the HD1K left camera, 8-bit grayscale, through rain and windshield wipers. Bottom: Hammerhead ARM depth from the same frames, computed on the CPU after NODAR calibration.
[ benchmarks ]
Measured on HD1K
HD1K is a public urban driving dataset: 1,083 frames in 36 scenes, 2560 x 1080 grayscale, 30 cm baseline, in clear, overcast and rainy daylight.
How fast is CPU-only stereo?
61.8 fps on one Cortex-A78 core at 1280 x 720.
16 to 27 fps on a six-core i.MX 95 at the full 2560 px input.
Processor
Cores
135 rows
67 rows
NVIDIA Orin AGX (Cortex-A78AE)
12
102.0 fps
169.5 fps
NXP i.MX 95 (Cortex-A55)
6
16.3 fps
26.8 fps
Raspberry Pi 3A+ (Cortex-A53)
4
5.5 fps
9.4 fps
HD1K, 2560 px wide input, CPU only. On the i.MX 95, six A55 cores run 16.3 fps (61.3 ms per frame) at 135 rows and 26.8 fps (37.3 ms) at 67 rows, 5.1x and 4.5x the single-core rate. Per core, the i.MX 95’s A55 is 1.8x faster than the Raspberry Pi 3A+’s A53, and Orin’s much larger A78AE about 5x. Fewer rows trade vertical density for frame rate: halving the rows gives about 1.65x the frame rate on six cores. Raspberry Pi figures were measured without thermal throttling at about 1.3 GHz. Under sustained load the Pi can throttle to 1.2 GHz.
Calibration from the images alone.
Even the benchmark needed it.
Stereo depth depends on knowing exactly how the two cameras sit relative to each other. HD1K ships with a calibration that is off in several scenes, worst in scenes 11 to 15 at about 2.1 px, or 0.07° of relative pitch. NODAR’s auto-calibration corrected it from the images alone, with no targets. Every error metric improved, and the gain grows with distance: at 90 to 100 m, Hammerhead ARM’s relative depth error drops 28%.
Rectification error per scene. Grey is the calibration as provided in HD1K, and blue is after NODAR’s auto-calibration.
0.74 → 0.44 px
Mean rectification error across all scenes
2.1 → 0.46 px
Worst scenes, 11 to 15, equal to 0.07° of relative pitch
Up to 8x
Lower disparity error in those scenes
The same HD1K frame, switching between the calibration as provided in HD1K and NODAR’s auto-calibration.
Simulated camera misalignment, before and after NODAR auto-calibration. Without it, depth breaks apart. With it, the street, pedestrian dummies and parked cars are reconstructed in full 3D.
[ perception safety ]
AI can be fooled by a picture.
Measured depth cannot.
NODAR checks what the neural network thinks it sees against physics-based depth.
In this street scene, a segmentation network flags a person painted on a wall as a pedestrian. The stereo point cloud shows a flat wall and no one there. Fusing network output with measured depth catches errors that inference alone misses, from the same cameras. Watch the full video
Top left: network segmentation on the camera image. Top right: confidence. Bottom left: depth colormap. Bottom right: 3D point cloud with the network’s detections.
[ working with nodar ]
A paid port, then a per-unit license.
Stop after any step.
The port assumes an ARM SoC running Linux. To start, we need your target board (or remote access) and sample stereo data.
Why the CPU
Lower BOM. Depth ships as a library on the SoC you already ship.
AI keeps its hardware. The GPU and NPU stay free.
Faster to market. A ported, tested depth library instead of building stereo in-house.
Robotics and industrial. High-quality depth on low-power ARM processors, without LiDAR or a GPU.
Field proven. NODAR depth runs with customers in automotive, agriculture, heavy equipment, rail and maritime. Hammerhead is already ported to TI TDA4 (depth plus YOLO object detection at 27 fps) and running on NXP i.MX 95.
The steps
Each step builds on the last. Production is a per-unit runtime license, tiered by volume. NODAR keeps ownership of the software, and you license the library on your target platform.
01
Feasibility sprint, 4 weeks: a report on range accuracy, compute headroom and the path to higher frame rates.
02
Optimized port, +6 weeks: optimized algorithm as a library (binaries plus API headers), with a benchmark report on your data.
03
Perception integration, +6 weeks: obstacle detection and segmentation alongside depth on the same chip, tuned on your field data.