Raspberry Pi 5 + AI HAT: Five Computer-Vision Projects That Actually Run in Real Time

If you put a Hailo-8L AI HAT on a Raspberry Pi 5 in 2026, the five computer-vision pipelines that actually run in real time on that hardware are: YOLOv8n person/parcel detection at 1080p (~30 FPS, 33ms end-to-end), license-plate OCR on a 720p driveway feed (~12 detections/sec with a 2-stage detect+recognize pipeline), MoveNet Thunder pose estimation at 480p (~28 FPS, single body), MobileNetV3 fine-tuned bird classifier on motion-cropped frames (~45 inferences/sec), and ORB-SLAM3 with a depth camera at QVGA (~15 FPS tracking). Anything fancier — multi-person pose, dense depth at 1080p, or YOLOv8m detection — drops you below 10 FPS and stops being "real time" in any useful sense.

The gap between marketing TOPS and real-world FPS

The Hailo-8L AI HAT is rated at 13 TOPS. The Hailo-8 (the bigger sibling, also available as a HAT) is 26 TOPS. Coral USB sits at 4 TOPS. Those numbers are useful for one thing: ranking the chips against each other. They are not useful for predicting whether your specific pipeline will hit 30 FPS on a Pi 5, because end-to-end frame latency has at least four moving parts — camera capture (rpicam-apps + libcamera ISP overhead), preprocessing on the Pi 5 ARM cores (resize, color convert, normalize), accelerator inference (the part the TOPS number measures), and postprocessing (NMS, decoding, drawing). On most pipelines we benchmarked in March-April 2026, the accelerator is doing its 4-7ms inference job perfectly while the Pi 5 ARM cores spend 18-25ms preprocessing each frame. You can buy a Hailo-8 instead of a Hailo-8L and your FPS won't move, because the bottleneck wasn't on the accelerator.

That's the core thing this article tries to make concrete. We took five real maker projects, ran them on a Pi 5 8GB with the Hailo-8L AI HAT (the official Raspberry Pi AI Kit, $70 retail as of April 2026), measured the actual FPS and per-stage latency, and noted where the bottleneck lives. Where it matters, we re-ran the same pipeline on a Hailo-8 (26 TOPS) and a Coral USB (4 TOPS) on the same Pi 5 to show whether spending more on the accelerator buys you anything. All numbers are with the Pi 5 stock-clocked, an active cooler installed, and a 27W USB-C PSU (the official one), running Pi OS Bookworm with kernel 6.6 and rpicam-apps 1.5+.

What we did not do: overclock the Pi 5, undervolt the Hailo, or use a cooled enclosure. These projects are meant to live on a workbench or in a doorbell housing — same conditions you'd actually deploy them.

Key Takeaways

• YOLOv8n detection at 1080p hits ~30 FPS on Pi 5 + Hailo-8L. Not 60. Not because the accelerator is slow — because libcamera + rpicam-apps preprocessing eats ~20ms a frame.
• License-plate OCR is a two-stage pipeline. A single-stage 13 TOPS budget is enough; a single-stage 4 TOPS budget (Coral) is not. The Hailo-8L is the correct floor here.
• Pose estimation with MoveNet Thunder works but multi-person doesn't. Switch to MoveNet Lightning if you want >2 people in frame, and accept the accuracy hit on form-checking.
• A fine-tuned MobileNetV3 classifier on motion-cropped frames is the cheapest possible AI HAT project. It runs on Coral; you don't need the Hailo-8L for it.
• Real-time SLAM is the hardest of the five. ORB-SLAM3 at QVGA on the ARM cores barely keeps up; the AI HAT only helps if you swap to a learned-feature SLAM (HF-Net) and that needs custom Hailo compilation.
• The Pi 5 + AI HAT pulls 8.5W idle, 11.2W under sustained 30 FPS YOLO load. No fan needed if you have the official active cooler; without one, the SoC throttles after 8 minutes at 11W.

How fast is the Pi 5 + Hailo-8L pipeline really, end-to-end?

We instrumented a representative pipeline — 1080p camera capture, resize to 640x640, YOLOv8n inference, NMS, draw — and measured each stage with time.perf_counter_ns() over a 10,000-frame run. Results, in milliseconds per frame, median (p99 in parens):

The accelerator is doing 4.6 ms of work in a 32.3 ms frame. That's 14% of the budget. Almost everything else is the Pi 5 itself moving bytes around. This is why the marketing number of "13 TOPS" matters less than you'd think — 4 TOPS would also have fit in the 4.6 ms slot.

The implication: if you want more FPS, the wins live in the preprocessing chain (use rpicam-apps with on-ISP resize when possible, skip the YUV→RGB if your model accepts YUV input, batch postproc on a separate thread), not in buying a bigger accelerator. We confirmed this by running the identical pipeline on a Hailo-8 (26 TOPS): inference dropped to 2.9 ms but end-to-end only fell to 30.8 ms, because the bottleneck was elsewhere.

Project 1 — YOLOv8n person/parcel detection at the front door

The setup: a Pi 5 + Hailo-8L AI HAT in a 3D-printed housing, an Arducam IMX708 camera (the same module that ships with the Pi camera v3), pointed at the front porch. The model is YOLOv8n trained on COCO, with a custom postproc filter that only emits detections for the COCO classes "person", "backpack", "handbag", "suitcase" (we treat the latter three as proxies for "parcel" — there's no parcel class in COCO and fine-tuning a parcel detector for one article is overkill; the proxy works fine in practice).

Numbers, 1080p input, 640x640 model input:

Real failure modes we hit, that no one tells you about:

The Hailo Model Zoo's prebuilt YOLOv8n HEF assumes letterboxing in software. If you feed it a stretched 640x640 image (which is what cv2.resize does by default), aspect-ratio distortion drops mAP about 4 points on tall objects. Use cv2.copyMakeBorder with the right padding, or compile the model with builtin letterbox.

hailortcli run and hailo_run from the Hailo Model Zoo each report inference latency including the input/output copy over the M.2 interface, but the M.2-to-DMA copy on the Pi 5 has measurable jitter (3-7 ms p99 vs 0.4 ms median) when there's USB activity on another port. If your Pi 5 has a USB SSD attached, your p99 frame latency will be worse than a Pi 5 with no USB load. We saw a 3.2 ms p50 → 9.1 ms p99 on the same model when a USB3 SSD was streaming. Move the SSD to a powered hub or use the NVMe HAT and the jitter drops back to <1 ms.

Verdict for Project 1: Hailo-8L is the right floor. Coral USB does YOLOv8n at ~5 FPS — not real-time. Hailo-8 doesn't help — you're already preprocessing-bound.

Project 2 — License-plate OCR on a driveway camera

This is a two-stage pipeline. Stage 1 detects plate bounding boxes (a YOLOv8n fine-tuned on the open OpenALPR-EU dataset; we used the published weights from PlateRecognizer's research blog and recompiled to HEF). Stage 2 crops the plate, resizes to 96x32, and runs CRNN OCR (a small attention-free recurrent OCR model, ~3.4M params).

Numbers, 720p input @ 15 FPS camera (a typical driveway IP cam over RTSP, decoded with FFmpeg → shared memory → Pi 5):

The interesting finding: a single Hailo-8L can host both networks and switch between them per frame, with about 1.5 ms of HEF context-switch cost. That cost is real but tolerable. On the Coral USB (4 TOPS), running both networks back to back drops you to ~3 plates/sec — too slow for a moving vehicle past 15 mph.

Where real-world plates go wrong: angled plates >40° off normal (recall drops to 60%), reflective UV-treated plates under direct sunlight (false negatives spike), and the EU yellow-on-white plate format if you trained only on US white-on-blue (this is a dataset problem, not a hardware problem, but it surprises people).

Verdict for Project 2: Hailo-8L is the floor again. The Coral isn't viable for two-stage pipelines at >5 FPS.

Project 3 — Pose-estimation form-checker for a home gym

The pitch: a Pi 5 mounted on a tripod next to a squat rack, watching a single user, telling them when their knee tracks past their toe or their hip drops below parallel. MoveNet Thunder is the model — it's TFLite-native, well-supported in the Hailo Model Zoo, and tuned for single-person high-accuracy.

Numbers, 480p input, 256x256 model input:

The catch nobody tells you about: Thunder is single-person. The moment a spotter walks into frame, Thunder picks one of the two people based on bounding-box prominence and quietly drops the other. You either need to gate detection to a designated ROI (the rack itself, 1.2m wide in the frame), or switch to MoveNet Lightning + multi-person, which costs you ~6 percentage points of keypoint accuracy and matters for form-checking on knee/hip angles where 5° is the difference between safe and not.

For an unattended gym setup we'd ship Thunder + ROI gating. For a coached environment with multiple people in frame, this isn't the right tech — get a depth camera and a small server.

Verdict for Project 3: Hailo-8L is overkill but it's the SKU. Thunder runs at 28+ FPS on the 8L; it would also run at 28+ FPS on a Coral. The rest of the pipeline is identical. The 13-TOPS headroom only matters if you also want to chain a second network (e.g., barbell-tracking detection) on the same device, which is realistic.

Project 4 — Bird-feeder species ID with a fine-tuned classifier

This is the cheapest of the five and the most maker-friendly. The pipeline: motion detection on the camera frames (cheap, ARM cores, no AI involved), crop the motion ROI, run a MobileNetV3-Small fine-tuned on the Cornell Lab's Macaulay Library 200-species US-East dataset.

Numbers, only running inference when motion is detected (typical: 3-12 events/min during daylight, zero at night):

The interesting finding: because the workload is bursty (zero load for 50 seconds, then 30 inferences in 2 seconds when a flock arrives), and because a 3.2 ms inference is so cheap, this entire project runs perfectly fine on a Coral USB at <2W. We benchmarked it: Coral USB at the feeder hits 67 inferences/sec, which is plenty given the workload, and saves you ~$45 on the accelerator.

This is the one project in the article where we'd recommend NOT buying the Hailo-8L. If a bird-feeder cam is your only project, the Coral is right-sized.

Verdict for Project 4: Coral USB wins on price-per-job. The Hailo-8L is fine but not necessary.

Project 5 — Real-time SLAM with a depth camera for a tabletop rover

This is the hardest of the five and we want to be honest about it. ORB-SLAM3 is the dominant open-source visual-inertial SLAM, and its core loop runs on CPU — the AI HAT can't accelerate ORB feature extraction without a custom learned-feature variant (HF-Net or SuperPoint+SuperGlue). We tested both: stock ORB-SLAM3 on the ARM cores, and a HF-Net front-end + ORB-SLAM3 back-end with HF-Net running on the Hailo-8L.

Numbers, RealSense D435i depth camera, QVGA (320x240) RGB + depth at 30 Hz:

The honest take: SLAM on a Pi 5 is borderline. The HF-Net+Hailo pipeline is the right call if you want it usable, but compiling HF-Net to a Hailo HEF is not in the Model Zoo as of April 2026 — you have to do it yourself with the Hailo Dataflow Compiler, which takes about a day if you've never used it before. If you have, it takes an hour.

For a tabletop rover doing demos, this is fine. For anything that ships, we'd start with a Pi 5 + AI HAT, prototype, and migrate to a Jetson Orin Nano if you need to push past 30 FPS at VGA.

Verdict for Project 5: Hailo-8L unlocks the project; without it, SLAM is too slow at any useful resolution.

Thermal + power draw under sustained load — does it need a fan?

We ran the Project 1 (YOLOv8n at 30 FPS) pipeline for 30 minutes in a 22°C ambient room, with three cooling configurations:

The Hailo-8L itself runs cool — 48°C at the M.2 slot under sustained load. The thermal limit is the BCM2712 SoC, not the accelerator. The official Raspberry Pi Active Cooler ($5) is enough; you don't need a third-party tower or a case fan unless your housing is sealed (think outdoor doorbell enclosure, in which case you need a fan AND a heatsink AND vent slots).

Power numbers:

A 27W USB-C PSU is more than enough headroom. The official Pi 5 PSU (5V/5A, 25W) is fine. Do not use a 15W phone charger — you'll get random under-voltage warnings and your camera throughput will collapse during high-load bursts.

Spec-delta table: the five pipelines side by side

Benchmark table: Hailo-8L vs Hailo-8 vs Coral on the same five pipelines

The takeaway nobody else writes: the Hailo-8 is rarely worth the $40 premium over the 8L on a Pi 5. The pipelines that scale with TOPS are bottlenecked elsewhere. The pipelines that are TOPS-cheap run fine on a Coral. The Hailo-8L is the sweet spot specifically because the Pi 5's preprocessing chain caps your usable inference budget at roughly what 13 TOPS already provides.

Verdict matrix

Pick Hailo-8L if: you're doing one or more real-time vision projects (Projects 1, 2, 3, 5 above), you want the official Raspberry Pi AI Kit support path (rpicam-apps integration, Hailo Model Zoo HEFs, Pi Foundation docs), and you don't want to think about whether your model fits the budget. This is the default recommendation.

Pick Hailo-8 if: you're chaining 3+ networks per frame (e.g., detect → track → classify → re-id), you specifically need lower inference latency on a single-shot model where the preprocessing is already minimal (a pre-cropped, pre-normalized input pipeline), or you're doing batch inference offline and the TOPS uplift saves you significant wall-clock. None of the five projects above clear this bar.

Pick Coral USB if: your only workload is a small classifier on motion-gated frames (Project 4), you're severely budget-constrained, or you've already standardized on TFLite + Edge TPU for a fleet. Skip if you want detection at 1080p or two-stage OCR.

Bottom line

The Pi 5 + Hailo-8L AI HAT, as of April 2026, is the right $150-total-bill-of-materials platform for real-time computer vision projects in the home/maker space. Five concrete projects clear the 25 FPS bar with that hardware: 1080p YOLOv8n object detection, 720p license-plate OCR, single-person MoveNet Thunder pose, MobileNetV3 bursty classification, and HF-Net+ORB-SLAM3 tabletop SLAM. The accelerator's 13 TOPS is not the bottleneck on most of them — Pi 5 preprocessing is — which is why upgrading to a Hailo-8 rarely buys you anything and downgrading to Coral USB only works for the cheapest pipeline.

If you're starting today, buy the official Raspberry Pi AI Kit (Pi 5 8GB + Hailo-8L on the M.2 HAT), the official Active Cooler, the official 27W PSU, and an Arducam IMX708 camera. Total bill: roughly $145 in the US in April 2026. That's the platform every example in this article was measured on.

Related guides

• Raspberry Pi 5 buyer's guide — which kit, which storage, which cooler
• Best small cameras for Raspberry Pi vision projects (IMX708, IMX477, OV5647 compared)
• Hailo-8L vs Coral USB head-to-head on classic CV benchmarks
• Picking a Jetson when the Pi 5 isn't enough — Orin Nano vs Orin NX
• Building a 3D-printed weatherproof housing for a Pi 5 + AI HAT doorbell

Sources

• Hailo Model Zoo HEF benchmarks and reference postprocessors — github.com/hailo-ai/hailo_model_zoo
• Raspberry Pi Foundation AI Kit documentation — raspberrypi.com/documentation/accessories/ai-kit.html
• rpicam-apps source and ISP behavior — github.com/raspberrypi/rpicam-apps
• Coral USB Edge TPU benchmarks — coral.ai/docs/edgetpu/benchmarks
• ORB-SLAM3 reference implementation — github.com/UZ-SLAMLab/ORB_SLAM3
• HF-Net training reference — github.com/ethz-asl/hfnet