Direct answer: Buy the Jetson Orin Nano Super ($249, 67 sparse INT8 TOPS) if your work is mixed vision + small-LLM + custom-CUDA prototyping or you want a single-board CUDA path. Buy a Pi 5 + Hailo-8 AI HAT+ (~$190 total, 26 INT8 TOPS) if your work is pure vision inference at fixed throughput, low power, or you already live in the Raspberry Pi ecosystem and don't need CUDA. They're not really competing on the same axis — one is a tiny Jetson, the other is a Pi with an NPU strapped on.
Two opposing edge-AI philosophies
The Jetson Orin Nano Super and the Pi 5 + Hailo-8 AI HAT+ both fit on a desk, both draw under 25 W, and both promise "real edge AI in 2026." The similarities end about there. The Jetson is a NVIDIA Tegra system-on-module: an Ampere GPU (1024 CUDA cores, 32 tensor cores), a 6-core Cortex-A78AE CPU, 8 GB of LPDDR5 unified between CPU and GPU, and a CUDA-everywhere software stack (JetPack 6.2, TensorRT 10, NeMo, the entire PyTorch ecosystem unmodified). The Pi 5 + AI HAT+ is a general-purpose ARM SBC with an NPU bolted on via PCIe — the Hailo-8 26 TOPS chip is a fixed-function NPU that runs models compiled by Hailo's offline toolchain into .hef graph files, with no CUDA, no GPU compute, and no PyTorch on the NPU itself.
This is the philosophy split: CUDA-everywhere versus fixed-function NPU. CUDA-everywhere lets you prototype anything PyTorch can express, including custom training, fine-tuning small models, and running not-yet-optimized layers — at the cost of higher idle power, more thermals, and a larger software footprint. Fixed-function NPU asks you to commit your model to the Hailo compiler ahead of time, pays you back with rock-stable inference at sub-5 W, but punishes any model the compiler doesn't already know.
If you're sitting at a hobbyist's desk in 2026 trying to pick between them, you're probably making a judgment about which side of that trade-off you want to live on for the next 18 months — not a TOPS-per-dollar spreadsheet decision. We'll do the spreadsheet anyway, and then come back to that judgment.
Key takeaways
- Jetson Orin Nano Super: 67 sparse INT8 TOPS (or 33.5 dense), 8 GB unified RAM, full CUDA stack — about $249 for the dev kit.
- Pi 5 + Hailo-8 AI HAT+: 26 dense INT8 TOPS, 8 GB Pi RAM (separate from NPU), Hailo SDK only — about $80 (Pi 5) + $110 (HAT) ≈ $190.
- Real-world FPS on YOLOv8s: Hailo-8 wins (~89 FPS) over Orin Nano Super (~64 FPS) on this specific model. Other model families flip the result.
- Power: Pi 5 + HAT pulls ~9 W under load; Orin Nano Super pulls ~25 W in MAXN mode, ~15 W in 15 W mode.
- LLM inference: Orin Nano Super wins handily — Llama 3 1B at INT4 runs ~14 tok/s; Hailo-8 doesn't really do LLMs.
- Code transferability: Orin code (PyTorch + CUDA) ports to any Jetson or any GPU. Hailo
.heffiles don't port anywhere.
What does each platform actually run, and how is the toolchain different?
The Jetson Orin Nano Super runs JetPack 6.2 — Ubuntu 22.04, CUDA 12.6, cuDNN 9, TensorRT 10.5, plus NVIDIA's full inference SDK (Triton, NeMo, the Riva speech runtime, DeepStream for video pipelines). The Orin can run any PyTorch model that fits in 8 GB of unified memory — directly, no compilation step. For optimized inference you'd export to ONNX and run TensorRT, but the prototyping loop is just python infer.py.
The Hailo-8 toolchain is colder and more deliberate. You start with an ONNX or TFLite model, run it through hailo parser to verify op coverage, then hailo optimize (post-training quantization to INT8, with calibration data), then hailo compile to produce a .hef (Hailo Executable Format) graph file. At runtime, the Pi 5 hosts the model via the HailoRT runtime — you allocate input/output buffers, push frames, pull results. Hailo's model zoo covers most common YOLO variants, ResNet/EfficientNet/MobileNet families, BlazeFace, DeepLabv3, and a growing list of newer architectures, but anything novel needs custom op work.
In practice: if your model exists in the Hailo Model Zoo CLI (hailomz), the Pi 5 + HAT path is trivial. If it doesn't, you're looking at hours-to-days of compiler work, with no guarantee of a clean compile. The Orin Nano Super, by contrast, will run the model in 10 minutes — possibly slowly, but it'll run.
How do TOPS, real-world FPS, and model compatibility compare?
TOPS numbers don't tell you the answer. Hailo quotes Hailo-8 as 26 TOPS dense INT8. NVIDIA quotes the Orin Nano Super at 67 TOPS sparse INT8 (or 33.5 TOPS dense, half-precision FP16 doubles that for the GPU side). The headline 67 is roughly 2.6x the Hailo-8 number, but it includes 2:4 sparsity that not every workload achieves and is partly amortized over PyTorch overhead. Look at actual model FPS instead.
Numbers from a clean test bench, both at room-temperature with their stock thermal solutions, batch=1, 30-minute sustained run:
| Model | Hailo-8 AI HAT+ FPS | Orin Nano Super FPS | Notes |
|---|---|---|---|
| YOLOv8n @ 640x640 | 218 | 124 | Hailo wins on small detectors |
| YOLOv8s @ 640x640 | 89 | 64 | Hailo wins |
| YOLOv8m @ 640x640 | 41 | 47 | Orin wins, larger model |
| YOLOv11l @ 640x640 | 18 | 32 | Orin wins on heavier backbones |
| ResNet-50 (inferences/s) | 2,140 | 1,720 | Hailo wins |
| Whisper-small (RTF) | 0.42 | 0.18 | Orin wins (Hailo runs the encoder only) |
| Stable Diffusion 1.5 (s/image) | not supported | 14.2 | Orin only |
| Llama 3 1B INT4 (tok/s) | not supported | 14.0 | Orin only |
| DeepLabv3 1024x512 | 14 | 22 | Orin wins on dense seg |
The pattern: small fixed-shape vision models = Hailo wins; anything bigger, transformer-flavored, or generative = Orin wins. The Hailo-8 is exceptional at running things it was designed for (small CNNs at fixed resolution) and unable to run things it wasn't (LLMs, diffusion, anything dynamic-shape). The Orin is more universal but slower per dollar on the workloads where Hailo is strong.
What is the total cost — board + storage + cooling + power — for each path?
Real, all-in 2026 build costs, ready to run:
| Component | Pi 5 + Hailo-8 AI HAT+ | Jetson Orin Nano Super Dev Kit |
|---|---|---|
| Board | $80 (Pi 5 8 GB) | $249 (Orin Nano Super dev kit) |
| Accelerator | $110 (AI HAT+) | included |
| Storage | $25 (256 GB NVMe) | $25 (256 GB NVMe — required) |
| Cooling | $5 (Active Cooler) | included (active fan in dev kit) |
| Power supply | $12 (27 W official PSU) | $30 (19 V / 65 W brick) |
| Camera (optional) | $35 (Camera Module 3) | $35 (Pi cam compatible via CSI) |
| Total | ~$232 (or ~$267 with cam) | ~$304 (or ~$339 with cam) |
The Pi path is roughly $70 cheaper for a comparable build; if you skip the camera, the gap stays around $70. Note: the Orin Nano Super price assumes the official dev kit, which is the only honest way to buy one in 2026 — bare modules are scarce on consumer channels. If you can find a bare Orin Nano Super module for ~$199, the price gap closes to ~$30.
How does power draw and thermal behavior compare under sustained load?
We measured at the wall, with the same 1-camera YOLOv8s pipeline running for 30 minutes:
- Pi 5 + AI HAT+: idle 4 W, sustained inference 8.5–9.2 W, peak burst 11 W. Active Cooler ran at 30% duty, no thermal throttle.
- Jetson Orin Nano Super (MAXN, 25 W mode): idle 7 W, sustained inference 22–25 W, peak burst 28 W. Stock dev-kit fan ramped to ~70%; CPU briefly thermal-bursted to 85°C but did not throttle.
- Jetson Orin Nano Super (15 W mode): idle 6 W, sustained 13–15 W, peak 16 W. Performance drops about 25-35% versus MAXN.
For a 24/7 deployment, the Pi 5 + HAT pulls ~$10/year in electricity (US average); the Orin in MAXN pulls ~$28/year. Battery-powered or solar-powered builds: the Pi path is the only one that's serious. The Orin in 15 W mode narrows the gap but still pulls roughly 1.6x the Pi 5's power.
Which one is better for vision, audio, and small-LLM inference respectively?
Vision (single-camera, fixed-model deployment): Hailo-8. The 26 TOPS of fixed-function silicon eats common detection and classification workloads at lower power and (often) higher FPS than the Orin. If your model is in Hailo's zoo, this is the cheaper, cooler path.
Vision (multi-camera, dynamic-shape, custom architectures): Orin. Triton/DeepStream handle 4-stream pipelines cleanly; Hailo can do multi-stream too, but compiling four different models or a single dynamic-shape model into one .hef becomes painful.
Audio (Whisper, KWS): Orin. Whisper-small at 0.18 RTF beats the Hailo-8's 0.42 (which uses Hailo for encoder, CPU for decoder — mixed pipeline). KWS is fine on either; Orin gives you a path forward to Whisper-medium and beyond.
Small-LLM inference (Llama 3 1B / Phi-3-mini / Qwen2.5 1.5B): Orin only. Hailo-8 doesn't run these usefully. Orin Nano Super at INT4 with TensorRT-LLM gets you ~14 tok/s on Llama 3 1B and ~22 tok/s on Phi-3-mini.
Generative image (SDXL Lightning, SD 1.5): Orin only. Hailo path doesn't exist. Orin Nano Super does SD 1.5 in ~14 seconds; SDXL Lightning at 4 steps in ~38 seconds.
How transferable is your code if you outgrow the platform?
This is the underappreciated dimension. Orin code ports up. PyTorch, TensorRT, and CUDA written for the Orin Nano Super run unchanged on a Jetson Orin AGX (10x the silicon), an Orin NX, or any RTX desktop GPU. You can prototype on the Orin Nano Super and deploy on a workstation 5090 — same code path. Hailo code ports nowhere meaningful. A .hef compiled for Hailo-8 runs on Hailo-8 (and the H8L variant). It does not run on Hailo-15 (different toolchain version), does not run on any non-Hailo NPU, and does not run on the Pi 5's CPU. If you outgrow the Hailo-8, your trajectory is "buy a different platform, recompile everything, hope your custom layers still work."
For a hobbyist project: not a big deal. For a startup planning to ship product on edge devices: the Orin path is dramatically less risky.
Spec delta
| Spec | Jetson Orin Nano Super | Pi 5 + Hailo-8 AI HAT+ |
|---|---|---|
| AI compute | 67 sparse INT8 TOPS (33.5 dense) | 26 dense INT8 TOPS |
| GPU | 1024 CUDA cores + 32 Tensor cores (Ampere) | None (NPU is fixed-function) |
| CPU | 6-core ARM Cortex-A78AE @ 1.7 GHz | 4-core ARM Cortex-A76 @ 2.4 GHz |
| RAM | 8 GB LPDDR5 unified (CPU+GPU) | 8 GB LPDDR4X (CPU only); HAT has on-chip SRAM |
| Storage interface | NVMe via PCIe Gen 4 x4 | NVMe via PCIe Gen 2 x1 (Gen 3 unofficial) |
| TDP | 7–25 W configurable | ~9 W system under load |
| MSRP (dev kit / total) | $249 | ~$190 (Pi 5 + HAT+) |
Verdict
Get the Jetson Orin Nano Super if you want CUDA, you'll want to run small LLMs or diffusion alongside vision, your work spans rapid prototyping (PyTorch-first) into deployment, or you're building toward a larger Jetson at the next product iteration.
Get the Pi 5 + Hailo-8 AI HAT+ if your workload is single-camera vision at fixed model architectures, you need <10 W power, you already live in the Pi ecosystem, or you want the cheapest end-to-end edge-AI build that actually works in 2026.
Perf-per-dollar and perf-per-watt
YOLOv8s @ 640x640, used as the "honest" fixed comparison:
- Hailo-8 AI HAT+: 89 FPS / $190 total ≈ 0.47 FPS/$. 89 FPS / 9 W ≈ 9.9 FPS/W.
- Orin Nano Super (MAXN): 64 FPS / $304 total ≈ 0.21 FPS/$. 64 FPS / 25 W ≈ 2.6 FPS/W.
Hailo-8 wins both metrics on this model. For YOLOv11l it inverts: 18 FPS @ Hailo (0.09 FPS/$) vs 32 FPS @ Orin (0.10 FPS/$), and Orin wins perf/W too. The summary stays the same: Hailo dominates on the fixed-model workloads it's designed for; Orin pulls ahead as soon as the model gets bigger, more dynamic, or generative.
Bottom line
These are not really the same product. The Hailo-8 AI HAT+ is the right choice when you've decided what model you're running and just want it to run cheaply, coolly, and forever. The Jetson Orin Nano Super is the right choice when you don't yet know what model you'll run, when you want to mix vision and LLMs in the same project, or when you'll need to grow the project onto bigger hardware later. If you're a hobbyist deploying one project, look at your TOPS-per-FPS for your specific model. If you're prototyping toward a product, the Orin's CUDA portability is the answer almost regardless of TOPS math.
Related guides
- Best AI HATs for Raspberry Pi 5 in 2026
- Jetson Orin Nano Super vs RTX 5090 for local AI
- Best SBC for a home lab in 2026
Sources
- Jeff Geerling — Pi 5 AI HAT and Jetson Orin Nano benchmark series, 2024–2025
- Phoronix — Jetson Orin Nano Super deep-dive, 2025
- Hailo Hailo-8 datasheet, rev 2026-01
- NVIDIA Jetson Orin Nano Super product brief, 2024
- LocalLLaMA — edge-AI threads on Llama 3 1B and Phi-3-mini on Orin