Edge AI Boards Compared: Raspberry Pi, Jetson, Arduino Uno Q, and ESP32-S3

Four boards now cover almost every edge AI job, from a 20mA wake-word listener to a 25W multi-camera vision node. The Raspberry Pi 5 with a Hailo accelerator, the NVIDIA Jetson Orin Nano Super, the Arduino UNO Q, and the ESP32-S3 each run neural networks in very different ways. Picking the wrong one costs you either power budget, money, or months of porting work. This guide compares them on compute, memory, power, tooling, and price, then shows how to combine them in one real system.

Quick Takeaways

  • Heaviest workloads (LLMs, multi-stream vision): Jetson Orin Nano Super, 67 TOPS (sparse INT8), CUDA, 7W/15W/25W power modes.
  • Best all-round Linux platform: Raspberry Pi 5 plus AI HAT+ 2 (Hailo-10H, 40 TOPS INT4) or the older AI HAT+ (13/26 TOPS).
  • Best hybrid for learning and robotics: Arduino UNO Q. A Cortex-A53 Linux MPU and a Cortex-M33 real-time MCU share one UNO-format board.
  • Cheapest always-on inference: ESP32-S3. Its 240MHz dual-core LX7 has vector instructions for TinyML, with deep-sleep currents in the microamp range.

Edge AI Boards at a Glance

Spec Raspberry Pi 5 + AI HAT+ 2 Jetson Orin Nano Super Arduino UNO Q ESP32-S3
Main compute 4x Cortex-A76 + Hailo-10H 6x Cortex-A78AE + Ampere GPU 4x Cortex-A53 @ 2.0GHz + STM32U585 2x Xtensa LX7 @ 240MHz
AI throughput 40 TOPS (INT4) 67 TOPS sparse / 33 TOPS dense (INT8) No dedicated NPU listed; CPU/GPU inference Vector instructions (no NPU)
Memory 2-16GB (Pi) + 8GB on HAT 8GB LPDDR5, 102GB/s 2GB or 4GB LPDDR4 + 16GB or 32GB eMMC 512KB SRAM + optional PSRAM
Power ~5V/5A supply recommended 7W / 15W / 25W modes 5V USB-C 3.3V, tens to hundreds of mA
OS / runtime Raspberry Pi OS, Hailo SDK JetPack, CUDA, TensorRT Debian + Zephyr, App Lab ESP-IDF, Arduino, TFLite Micro
Best for Vision, local LLM/VLM Generative AI, robotics Mixed Linux + real-time control Keyword spotting, sensor ML
Price (Nov 2026) Pi 5 8GB $180 + HAT $200 $249 list ~$55 (2GB) / ~$66 (4GB) Roughly $8-$20 dev board

TOPS figures are vendor ratings with different numeric precisions. INT4 TOPS, sparse INT8 TOPS, and dense INT8 TOPS are not directly comparable. Benchmark your own model before you commit.

Raspberry Pi 5 + AI HAT+ 2

Component Overview

The Raspberry Pi 5 is a general-purpose Linux computer. It has no NPU. It reaches 40 TOPS only when you add the AI HAT+ 2, which Raspberry Pi released in January 2026. The HAT carries a Hailo-10H accelerator and 8GB of dedicated LPDDR4X. That onboard memory is the key upgrade: the model’s weights stay on the HAT, so the host’s RAM remains free for the OS, camera pipeline, and your application.

The HAT talks to the Pi over PCIe through the Pi 5’s dedicated connector. This means it works only with the Pi 5, not the Pi 4 or Zero.

Vision vs. Generative AI

Raspberry Pi states that computer-vision performance on the AI HAT+ 2 is comparable to the older 26 TOPS AI HAT+. The Hailo-10H adds support for LLMs and VLMs. If you only run object detection with YOLO, the older Hailo-8 HAT+ (26 TOPS) or Hailo-8L version (13 TOPS) is the better value. Pick the AI HAT+ 2 when you need a small local language model.

Pricing Reality

Memory shortages pushed Pi prices up repeatedly through 2026. As of October 2026, the Pi 5 sits at $110 (4GB) and $180 (8GB). The 16GB model reached $385 in November. The AI HAT+ 2 launched at $130 and is now listed at $200 on Raspberry Pi’s product page. Price the full stack before you design around it.

Quick Test Command

After mounting the HAT and updating Raspberry Pi OS, run a hardware-accelerated detection demo with the camera stack:

# Update the OS so the Hailo runtime and rpicam-apps are current
sudo apt update && sudo apt full-upgrade -y
sudo apt install -y hailo-all   # Hailo drivers, firmware, and TAPPAS post-processing
sudo reboot

# Verify the accelerator is detected over PCIe
hailortcli fw-control identify

# Run YOLOv8 object detection on the camera preview, inference on the Hailo chip
rpicam-hello -t 0 --post-process-file /usr/share/rpi-camera-assets/hailo_yolov8_inference.json

NVIDIA Jetson Orin Nano Super

Component Overview

The Jetson Orin Nano Super Developer Kit is the most capable board in this comparison. It pairs a 6-core Arm Cortex-A78AE CPU at up to 1.7GHz with an Ampere GPU. NVIDIA rates it at 67 TOPS sparse INT8 (33 TOPS dense). The module has 8GB of 128-bit LPDDR5 at 102GB/s. Memory bandwidth, not raw TOPS, usually limits LLM token speed, and this is where Jetson beats the others.

NVIDIA cut the kit price from $499 to $249 when it introduced the Super mode in December 2024. Owners of the earlier kit can reach the same performance with a JetPack 6.2 update. Stock and pricing have fluctuated since, because of component costs and tariffs, so check your distributor.

Power Modes

The Super firmware adds a 25W mode and a MAXN SUPER mode alongside 15W. The module also supports 7W. You trade performance for battery life by switching modes at runtime:

# Show the current power mode and list the available ones
sudo nvpmodel -q
# Select a mode by ID (confirm IDs in /etc/nvpmodel.conf on your JetPack version)
sudo nvpmodel -m 2
# Lock clocks at the maximum allowed by the active mode
sudo jetson_clocks
# Live monitoring of GPU load, memory, and power rails
sudo tegrastats

Software Stack

Jetson’s real advantage is software. CUDA, cuDNN, and TensorRT are standard. You can export a PyTorch model to ONNX, build a TensorRT engine, and run it with FP16 or INT8 precision. DeepStream handles multi-camera pipelines, and community containers cover local LLM serving.

# Run an Ultralytics YOLO model on the Jetson GPU (requires the Jetson-specific PyTorch wheel)
from ultralytics import YOLO

model = YOLO("yolo11n.pt")
model.export(format="engine", half=True, device=0)  # build a TensorRT FP16 engine

trt_model = YOLO("yolo11n.engine")
# Stream from a CSI/USB camera; inference runs on the GPU Tensor Cores
for result in trt_model.predict(source=0, stream=True, imgsz=640):
    print(len(result.boxes), "objects detected")

The trade-offs are power draw, a larger footprint, and a heavier Linux setup than a Pi.

Arduino UNO Q

Component Overview

The UNO Q arrived after Qualcomm’s acquisition of Arduino. It places two processors on one board in the classic UNO form factor, so existing shields and many libraries still apply.

  • Qualcomm Dragonwing QRB2210: quad-core Cortex-A53 at 2.0GHz, an Adreno GPU, and two ISPs. It runs Debian Linux.
  • STMicroelectronics STM32U585: a Cortex-M33 MCU running Arduino sketches on Zephyr OS.

The board has 2GB or 4GB of LPDDR4, plus onboard eMMC storage, dual-band Wi-Fi 5, and Bluetooth 5.1.

Where It Fits

Arduino pitches the UNO Q for “lightweight AI.” Treat that literally. The QRB2210 is an entry-level application processor, and Arduino does not list a dedicated NPU. Expect small vision models such as keyword spotting, simple classification, and low-resolution detection to run in Python on the CPU or GPU. It will not match a Hailo or Jetson on throughput.

Its value is the split architecture. The MCU handles hard real-time jobs: PWM, motor control, I2C and SPI sensor sampling, and shield I/O. The MPU handles camera input, inference, and networking. The Arduino App Lab IDE links the two sides with a bridge, so a Python script can call functions in your sketch.

Bridge Example

On the MCU, expose a function:

// Sketch running on the STM32U585 (Zephyr core)
#include <Arduino_RouterBridge.h>

void setLed(bool on) {
  digitalWrite(LED_BUILTIN, on ? LOW : HIGH);   // onboard LED is active-low
}

void setup() {
  pinMode(LED_BUILTIN, OUTPUT);
  Bridge.begin();                      // start the MPU<->MCU RPC link
  Bridge.provide("set_led", setLed);   // make the function callable from Linux
}

void loop() {}

On the Linux side, call it from your inference loop:

# Python app running on the QRB2210 inside Arduino App Lab
from arduino.app_utils import *

def loop():
    detected = run_my_model()          # your classifier or detector
    Bridge.call("set_led", detected)   # real-time actuation on the MCU

App.run(user_loop=loop)

Library names and APIs in App Lab are still evolving, so verify them against the current Arduino docs.

ESP32-S3

Component Overview

The ESP32-S3 is a microcontroller, not a computer. It has a dual-core Xtensa LX7 at 240MHz, 512KB of internal SRAM, 2.4GHz Wi-Fi, Bluetooth 5 (LE), and up to 45 GPIO pins. Dev boards commonly add 8MB of octal PSRAM and 16MB of flash, which matters for camera buffers and larger models.

AI Acceleration

Its edge over the original ESP32 is a set of 128-bit vector instructions for 8-bit and 16-bit multiply-accumulate operations. Espressif exposes them through ESP-NN (neural network kernels), ESP-DSP, and ESP-DL. TensorFlow Lite Micro uses ESP-NN automatically when you build with it. Community benchmarks put the S3 roughly 3-5x ahead of the original ESP32 on comparable models.

Realistic workloads include:

  • Wake-word and keyword spotting
  • Anomaly detection on vibration or current sensors
  • Gesture classification from an IMU
  • Face detection at low frame rates with ESP-WHO

TFLite Micro Skeleton

// ESP32-S3 TinyML skeleton (Arduino core with a TensorFlow Lite Micro library)
#include <TensorFlowLite_ESP32.h>   // library name varies; use the one matching your core
#include "tensorflow/lite/micro/micro_interpreter.h"
#include "tensorflow/lite/micro/micro_mutable_op_resolver.h"
#include "model_data.h"             // int8 model exported with: xxd -i model.tflite

constexpr int kArenaSize = 120 * 1024;           // tensor arena; tune to your model
static uint8_t *tensor_arena;
static tflite::MicroInterpreter *interpreter;

void setup() {
  Serial.begin(115200);
  // Allocate the arena in PSRAM so internal SRAM stays free for Wi-Fi and the stack
  tensor_arena = (uint8_t *)heap_caps_malloc(kArenaSize, MALLOC_CAP_SPIRAM);

  static tflite::MicroMutableOpResolver<4> resolver;
  resolver.AddConv2D();
  resolver.AddFullyConnected();
  resolver.AddSoftmax();
  resolver.AddReshape();

  const tflite::Model *model = tflite::GetModel(g_model_data);
  static tflite::MicroInterpreter static_interp(model, resolver, tensor_arena, kArenaSize);
  interpreter = &static_interp;
  interpreter->AllocateTensors();
}

void loop() {
  TfLiteTensor *input = interpreter->input(0);
  // Fill input->data.int8[] with quantized sensor or audio features here
  uint32_t t0 = micros();
  interpreter->Invoke();                          // runs on the LX7 with vector-accelerated kernels
  Serial.printf("Inference: %lu us\n", micros() - t0);
  delay(100);
}

Always quantize to INT8 for the S3. Float models run far slower and consume more memory.

Choosing the Right Board

Use this decision table to narrow the field fast:

Your requirement Best pick Why
Run a small LLM or VLM locally Jetson Orin Nano Super 102GB/s memory bandwidth, CUDA, TensorRT
Several 1080p camera streams with detection Jetson or Pi 5 + Hailo Hardware video decode and strong throughput
One camera, low cost, simple setup Pi 5 + AI HAT+ (26 TOPS) Native camera stack, mature community
Real-time motor control plus basic vision Arduino UNO Q Dedicated MCU next to a Linux MPU
Battery-powered sensor node ESP32-S3 Deep-sleep currents in the microamps
Wake-word or keyword detection ESP32-S3 ESP-SR, ESP-NN, tiny BOM
Learning embedded Linux and Arduino together Arduino UNO Q One board, one IDE

Practical Workflow: A Tiered Smart-Entrance System

One board rarely does everything well. A tiered design gives each processor the job it handles best.

Tier 1: ESP32-S3 (always on). Wire a PIR sensor to a GPIO and run a small keyword model on a PDM or I2S microphone. The S3 sleeps until motion or a wake word appears. Average current stays tiny.

Tier 2: Arduino UNO Q (real-time control). The STM32U585 drives a door strike through a MOSFET and reads a reed switch over GPIO. The QRB2210 runs a lightweight person classifier on a CSI or USB camera frame. Use a flyback diode across the lock coil and a separate 12V supply for the actuator.

Tier 3: Jetson or Pi 5 + Hailo (heavy analysis). Only when Tier 2 flags a person does the system send frames over MQTT or HTTP to the heavy node. That node runs a recognition model, or a VLM that describes the scene, and logs the result.

Wiring notes for the S3-to-UNO Q link:

  1. Share a common GND between all boards.
  2. Level-shift if you connect any 5V logic to ESP32-S3 GPIO. The S3 is 3.3V only and is not 5V tolerant.
  3. Prefer UART at 115200 baud or Wi-Fi/MQTT over long wires. For wired links under one meter, I2C at 400kHz works well.
  4. Add a 100nF decoupling capacitor close to each module’s VCC pin to suppress switching noise.

This layout lets the heavy board stay powered down most of the time, which cuts energy use sharply compared with running a 25W Jetson continuously.

Common Pitfalls

  • Comparing TOPS across boards. A 40 TOPS INT4 rating and a 67 TOPS sparse INT8 rating describe different precisions. Compare frames per second on your model.
  • Ignoring memory. An LLM with 4-bit weights still needs several gigabytes. The ESP32-S3 and the UNO Q‘s MCU cannot host one.
  • Skipping cooling. The Pi 5 with a HAT needs an active cooler under sustained load, and Raspberry Pi advises a heatsink for heavy AI workloads. Jetson in MAXN SUPER mode needs real airflow.
  • Underpowering the Pi. Use a supply rated for 5V/5A when the HAT and USB peripherals draw current.
  • Skipping quantization. Full-precision models rarely fit on microcontrollers.

FAQ

Which is the best edge AI board for beginners?

The Raspberry Pi 5 with an AI HAT+ is the easiest start. It runs standard Raspberry Pi OS, the camera demos work with a few commands, and the community is large. The Arduino UNO Q is a good second choice if you already know Arduino and want Linux and real-time I/O on one board.

Can an ESP32-S3 really run machine learning?

Yes, within limits. Its vector instructions and ESP-NN kernels run quantized INT8 models for keyword spotting, sensor classification, and basic face detection. It cannot run large vision models or language models. It has 512KB of internal SRAM, plus optional PSRAM.

Is the Jetson Orin Nano Super better than a Raspberry Pi 5 with an AI HAT?

For generative AI and multi-stream vision, yes. It offers 67 TOPS sparse INT8, CUDA, and 102GB/s memory bandwidth. The Pi 5 with a Hailo HAT costs less to run, uses less power, and handles single-camera detection well. If your workload is plain object detection, the cheaper Hailo setup is often enough.

Does the Arduino UNO Q have an NPU?

Arduino does not list a dedicated NPU for the Dragonwing QRB2210. The board runs small models on its Cortex-A53 CPU and Adreno GPU. For larger models, pair it with an external accelerator or send frames to a more powerful node.

Hot this week

How to Test Components: Resistors, Diodes, Transistors, and Capacitors

Learn how to test components like resistors, diodes, transistors, and capacitors with a multimeter. Follow the steps and start testing now.

The Serial Monitor: Your Best Debugging Tool

Learn to debug Arduino and ESP32 projects with the Serial Monitor. Master Serial.print, baud rates, and tricks to fix bugs fast. Start debugging now.

SSH, VNC, and Raspberry Pi Connect: Remote Access Options Compared

SSH, VNC, or Raspberry Pi Connect? Compare setup, speed, security, and use cases, then pick the best way to control your Pi remotely. Read the guide.

How to Troubleshoot a Dead Circuit: A Systematic Method

Learn a step-by-step method to troubleshoot a dead circuit: check power, trace voltages, test components, and fix faults fast. Start diagnosing now.

Fume Extraction and Lead-Free Solder: Is Soldering Safe?

Is soldering safe? Learn what's in solder fumes, how lead-free solder changes the risk, and how to set up proper extraction. Read the guide now.

Topics

How to Test Components: Resistors, Diodes, Transistors, and Capacitors

Learn how to test components like resistors, diodes, transistors, and capacitors with a multimeter. Follow the steps and start testing now.

The Serial Monitor: Your Best Debugging Tool

Learn to debug Arduino and ESP32 projects with the Serial Monitor. Master Serial.print, baud rates, and tricks to fix bugs fast. Start debugging now.

SSH, VNC, and Raspberry Pi Connect: Remote Access Options Compared

SSH, VNC, or Raspberry Pi Connect? Compare setup, speed, security, and use cases, then pick the best way to control your Pi remotely. Read the guide.

How to Troubleshoot a Dead Circuit: A Systematic Method

Learn a step-by-step method to troubleshoot a dead circuit: check power, trace voltages, test components, and fix faults fast. Start diagnosing now.

Fume Extraction and Lead-Free Solder: Is Soldering Safe?

Is soldering safe? Learn what's in solder fumes, how lead-free solder changes the risk, and how to set up proper extraction. Read the guide now.

RTL-SDR on Raspberry Pi: Software-Defined Radio for Beginners

Set up an RTL-SDR on Raspberry Pi: install drivers, tune FM, track aircraft with ADS-B, and decode signals. Follow the step-by-step guide.

Understanding the Sketch Structure: setup(), loop(), and Beyond

Learn how Arduino setup(), loop(), globals, and custom functions work, with code, a hidden main() breakdown, and fixes. Read the guide and start coding.

Electronics Safety: Mains Voltage, Batteries, and Soldering Hazards

Learn how to stay safe around mains voltage, LiPo batteries, and soldering fumes. Use our bench checklists and build safely today.

Related Articles

Popular Categories