Companion shootout: Jetson Orin Nano Super vs RPi 5 + Hailo-8L

This is the companion computer decision post. Last week I committed to a single companion for this build (rather than the RPi 5 + Jetson split-companion architecture I’d originally planned). This post walks through the three options I considered, why the split got cut, and which single companion I’m picking — with the reasoning that actually matters for a build at this scope.

If you only have ten minutes: read the TL;DR, skim the benchmarks, then jump to the recommendation. If you want the full reasoning: keep going.

TL;DR

For an autonomous drone project that commits to visual obstacle avoidance + GPS-denied navigation with VINS-Fusion + ORB-SLAM3 — which is what the manifesto commits to — the answer is Jetson Orin Nano Super (8 GB) as a single companion.

The RPi 5 + Hailo-8L combo is a genuinely viable alternative if your scope is narrower (budget, nav/control only, simpler obstacle avoidance). The split-companion architecture (RPi 5 + Jetson) is real research-grade engineering but overkill for a development drone that operates line-of-sight.

What “companion computer” actually means

The companion computer is the brain of the drone, distinct from the autopilot. The autopilot (Cube Orange+ in this build) runs low-level control loops, sensor fusion, and safety. The companion runs the high-level intelligence: where to fly, what to look for, how to react to obstacles, when to land.

For a manual FPV drone, there is no companion — the pilot is the intelligence. For an autonomous drone, the companion is essential. It runs ROS2, communicates with the autopilot via MAVROS2, and provides the perception + planning capabilities that turn “a drone that can fly” into “a drone that can do something useful.”

The question is: which one?

The three viable architectures

Option 1 — Raspberry Pi 5 + Hailo-8L

The Pi 5 is the latest Raspberry Pi. The Hailo-8L is an M.2 AI accelerator designed specifically for the Pi 5 (via the Raspberry Pi AI Kit). Together they’re a $150 vision- capable companion.

┌─────────────────────────────┐
│  Raspberry Pi 5 (8 GB)      │
│  + Hailo-8L AI accelerator  │
│                             │
│  ROS2 Jazzy                 │
│  MAVROS2                    │
│  Hailo runtime for YOLO     │
│  CPU-only SLAM (slow)       │
└─────────────────────────────┘
        │
        │  TELEM2 UART (MAVLink)
        ▼
  Cube Orange+ (PX4)

Cost: $150 ($80 Pi + $70 Hailo AI Kit)

Pros:

Cheapest viable vision-capable option
~5 second boot (fastest of the three)
5V USB-C power (simplest BEC)
~8W peak power draw
Mature ROS2 Jazzy on Ubuntu 24.04
Hailo-8L does YOLO inference at ~30 fps after model compilation
WiFi 5 + GbE built in

Cons:

No GPU for general vision processing
VINS-Fusion runs at ~10-15 Hz on Pi CPU (vs 30 Hz on Jetson)
ORB-SLAM3 with proper GPU descriptor matching is impractical
Hailo requires model compilation step; new architectures are a 30+ minute compile
8 GB RAM is shared with system; ~5-6 GB available for ROS2
13 TOPS is enough for YOLO but tight for multi-model inference

Option 2 — Jetson Orin Nano Super (recommended)

The Jetson Orin Nano Super is NVIDIA’s mid-tier AI edge computer. 40 TOPS of AI performance, 1024-core Ampere GPU, 8 GB unified CPU/GPU memory, $250.

┌─────────────────────────────┐
│  Jetson Orin Nano Super     │
│  (8 GB unified memory)      │
│                             │
│  ROS2 Jazzy                 │
│  MAVROS2                    │
│  YOLO11 via TensorRT        │
│  VINS-Fusion / ORB-SLAM3    │
│  Nav2 local planner         │
│  Optional: VLM inference    │
└─────────────────────────────┘
        │
        │  TELEM2 UART (MAVLink)
        ▼
  Cube Orange+ (PX4)

Cost: $250

Pros:

40 TOPS (3× Hailo-8L)
1024-core Ampere GPU + 32 Tensor cores
8 GB unified memory (no CPU/GPU split)
CUDA + TensorRT + cuDNN — canonical robotics AI ecosystem
VINS-Fusion at 30 Hz with proper config
ORB-SLAM3 with GPU descriptor matching
YOLO11 inference at full frame rate
Same JetPack 6.x as bigger Jetsons (Orin NX, AGX) — clean upgrade path
Isaac ROS packages available
Isaac Sim compatibility for digital twin
The default for any serious AI robotics project in 2026

Cons:

$250 (vs $150 Pi+Hailo)
7-25W power draw (vs 8W Pi)
15-25 second boot time (vs 5s Pi)
Needs active cooling (fan included in dev kit)
More complex OS (JetPack based on Ubuntu)
7-20V input requires a BEC (vs 5V USB-C for Pi)

Option 3 — Split-companion (RPi 5 + Jetson)

The split-companion architecture uses two companion computers. The RPi 5 handles the ROS2 + MAVROS2 + failsafe path. The Jetson handles the vision + SLAM + planning. They communicate over Gigabit Ethernet via ROS2 DDS.

┌──────────────────┐  ┌──────────────────┐
│  RPi 5           │  │  Jetson          │
│  ROS2 + MAVROS2  │──│  Vision + SLAM   │
│  Safety path     │  │  Non-critical    │
│  Fast boot       │  │  High compute    │
└──────────────────┘  └──────────────────┘
        │                    │
        └──── GbE (DDS) ─────┘
                       │
                       │  TELEM2
                       ▼
                 Cube Orange+ (PX4)

Cost: $330 ($80 Pi + $250 Jetson)

Pros:

Safety isolation (Jetson can crash without affecting flight)
Faster boot of the safety-critical companion (5s vs 25s)
Failure isolation, power isolation, thermal isolation
The pattern used by ETH ASL, UZH RPG, MIT ASL — academic research-gradeomot

Cons:

Two computers to power, mount, wire, cool, configure
DDS over Ethernet adds setup complexity
The safety story matters mostly for BVLOS / high-consequence missions
More points of failure for a development drone

Why I’m cutting the split-companion option

I originally planned to build the split-companion architecture for this project. After working through the trade-offs in detail, I’m cutting it. Here’s why.

The safety argument doesn’t pay off at this scope

The split-companion architecture’s main benefit is safety isolation: if the AI co-processor crashes mid-flight, the primary companion can still command a return-to-launch. This is genuinely valuable for BVLOS missions, swarms, or operations in populated areas.

For a development drone that operates line-of-sight, in a controlled test area, with a safety pilot on the controls — which is what this project actually is — the safety isolation benefit is marginal. The Cube Orange+ itself has internal failsafes that will land the drone if the companion is completely unresponsive. The extra safety from isolating the Jetson doesn’t justify the extra complexity.

The complexity cost is real

Two companion computers means:

Two power systems (5V BEC for Pi, 7-20V BEC for Jetson)
Two mounts with vibration isolation
Two network connections (MAVLink to Pi, DDS between Pi and Jetson)
Two OS configurations (Ubuntu 24.04 on Pi, JetPack on Jetson)
Two DDS configurations (CycloneDDS on Pi, CycloneDDS on Jetson, both pointing at each other)
Two boot sequences
Two log streams to correlate during debugging

For a research project where the goal is to learn the stack, this is more setup than signal. Single companion lets us focus on the actual work.

We can revisit later

If Year 2 of this project expands to BVLOS missions or swarm work, the split-companion architecture becomes more attractive. We’re not closing the door permanently — we’re recognizing that for the Year 1 scope, it’s overkill.

Benchmark: what matters for an autonomous drone

Metric	RPi 5 + Hailo-8L	Jetson Orin Nano Super
Cost	$150	$250
AI compute (TOPS)	13	40
GPU	None	Ampere 1024-core
RAM (available for ROS2)	~5 GB	8 GB (unified)
Boot time	~5 sec	~15-25 sec
Idle power	4 W	7 W
Peak power	8 W	25 W
VINS-Fusion rate (typical)	10-15 Hz	30 Hz
ORB-SLAM3	Slow (CPU-only)	Full GPU
YOLO11 inference	~30 fps (compile)	~60 fps (TensorRT)
ROS2 Jazzy	Native	Native
CUDA / TensorRT	No	Yes
Isaac ROS	Limited	Full
Isaac Sim	No	Yes
Upgrade path to AGX Orin	No	Yes
WiFi	Built-in	Built-in
GbE	Built-in	Built-in

The TOPS number (13 vs 40) understates the practical difference. The Jetson wins on:

Unified memory. No PCIe round-trips between detection and SLAM. The Pi + Hailo architecture has to shuttle frames between Pi RAM and Hailo RAM, costing 5-15 ms per frame.
CUDA ecosystem. VINS-Fusion, ORB-SLAM3, and most state-of-the-art robotics algorithms ship with CUDA optimizations. The Pi gets CPU-only implementations.
TensorRT. Real-time inference with model compilation is a solved problem on Jetson. On Pi+Hailo, you compile for the Hailo accelerator; you can’t run arbitrary networks without a 30+ minute compile step.
Isaac ROS. NVIDIA’s ROS2 packages for perception, SLAM, and navigation are first- class on Jetson. On Pi, you can run some of them but lose GPU acceleration.

What the Jetson actually costs you

The $100 difference between Pi+Hailo and Jetson is real. Here’s what it buys:

3× the AI compute. Means you can run YOLO + depth + SLAM + planning concurrently without dropping frames.
CUDA ecosystem. Means VINS-Fusion and ORB-SLAM3 work as designed, not at 1/3 speed.
TensorRT. Means you can iterate on model architectures quickly without a compile step.
Isaac ROS. Means you have access to NVIDIA’s production-grade ROS2 perception packages.
Upgrade path. Same JetPack as Orin NX and AGX — you can swap in a bigger module later without rewriting code.

For a project whose stated goal is to learn AI robotics deeply and build authority in the space, these are worth the $100.

What the Pi + Hailo actually costs you

If you go Pi + Hailo, here’s what you give up:

SLAM performance. VINS-Fusion at 10-15 Hz is workable but not great. ORB-SLAM3 is genuinely hard to get running well on Pi.
Model iteration speed. Each Hailo model compile is 30+ minutes. On Jetson with TensorRT, it’s ~5 minutes.
GPU-accelerated perception. Anything that uses CUDA (which is most state-of-the-art robotics) runs CPU-only on Pi.
The canonical learning path. Building on Jetson teaches the stack used in industry and academia. Building on Pi+Hailo teaches a more constrained subset.

For a project focused on navigation and control with simple obstacle avoidance, these losses are acceptable. For a project committed to visual SLAM and vision-based autonomy, they’re significant.

What about Pi 5 without Hailo?

You can run ROS2 + MAVROS2 + simple obstacle detection (depth only, no YOLO) on a Pi 5 without any accelerator. The trade-off is no AI inference at all. This works for drones focused on navigation and control, where “obstacle avoidance” means “use depth data to stop” rather than “use YOLO to identify what the obstacle is.”

For this project, that scope is too narrow. The manifesto commits to visual obstacle avoidance with object identification, which means YOLO-class inference is required.

The decision

For this build, I’m going with Jetson Orin Nano Super (8 GB) as the single companion.

Reasons, in order of weight:

The manifesto commits to visual SLAM, YOLO-class detection, and GPS-denied navigation. These are GPU-heavy workloads. The Jetson is the right tool.
The Jetson is the canonical AI robotics platform in 2026. Building on it teaches the stack used in industry and academia.
The $100 cost difference is real but small relative to the rest of the BOM. The whole project is ~$2,000-2,500; saving $100 on the companion is a 4-5% optimization that significantly constrains the build.
The split-companion architecture is overkill for development work. The safety isolation it provides doesn’t pay off until we’re doing BVLOS or high-consequence operations.
We can revisit split-companion in Year 2 if the scope expands.

What to order

See docs/bom.md for the updated bill of materials with the Jetson path priced out.

Short version: ~$250 for the Jetson + ~$40 for the 12V BEC + ~$50 for mount + ~$50 for wiring. Total companion-related: ~$390.

What’s next

Week 6: Companion setup on the drone — JetPack 6.x install, ROS2 Jazzy, MAVROS2, CycloneDDS config, first heartbeat to the Cube.

If you want to follow along, subscribe for the weekly drop.

— Shane