Playground · app-grounded instrument
On-device AIEdge AI SBC & Hardware Accelerator Explorer
Benchmark single-board computers and hardware accelerators for edge computing. Compare real-time latency, memory bandwidth bottlenecks, TOPS/Watt efficiency, and thermal power draw across LattePanda, Jetson, Coral TPU, and Raspberry Pi.
Edge Hardware Configuration
Simulated Performance Metrics
Real-Time EstimatorQuick Hardware Comparison
At-a-glance specs for all five supported edge hardware targets. Select any board above to explore detailed interactive benchmarks.
| Board / Accelerator | Architecture | Peak TOPS | Mem BW | Max TDP | Best For |
|---|---|---|---|---|---|
| Jetson Orin Nano Super | ARM + 1024 CUDA | 33.0 | 102.0 GB/s | 25W | Vision, LLMs, TensorRT |
| Google Coral USB TPU | USB 3.0 Edge TPU | 4.0 | 0.5 GB/s† | 2W | INT8 vision, ultra low-power |
| Raspberry Pi 5 8GB | ARM Cortex-A76 | 0.61† | 17.0 GB/s | 12W† | Hobbyist, edge servers |
| LattePanda 3 Delta | x86_64 Celeron | 0.31† | 23.5 GB/s† | 10W | x86 compat, Windows IoT |
| ESP32-S3 DevKitC | Xtensa LX7 Dual | 0.0154† | 0.16 GB/s† | 0.36W† | MCU TinyML, wake-word |
TOPS is dense INT8 throughput, because every workload modelled here is a dense network. A † marks a figure the vendor does not publish, derived here with the arithmetic shown below. The power column is not five comparable TDPs — each row states which quantity it is.
Where every number comes from
- Jetson Orin Nano Super
TOPS 33.0 — NVIDIA DS-11105-001_v1.5, Jetson Orin Nano 8GB: "Dense - 20 INT8 TOPs - 33 INT8 TOPs (MAXN_SUPER)". The widely quoted 67 is the SPARSE figure; this page models dense networks, so 67 would make compute time 2x optimistic.
BW 102.0 GB/s — NVIDIA DS-11105-001_v1.5: 128-bit LPDDR5 at up to 3199 MHz under MAXN_SUPER. 16 bytes x 6398 MT/s / 1000 = 102.4 GB/s. The pre-Super 2133 MHz gives 16 x 4266 / 1000 = 68.3 GB/s, which is the figure D-245 found spliced onto this row.
Power 25 W — NVIDIA DS-11105-001_v1.5: "Jetson Orin Nano 8GB Modes: 7W | 15W | 25W (MAXN_SUPER)". Module power mode — the developer kit's carrier, NVMe and fan draw on top of it.
- Google Coral USB TPU
TOPS 4.0 — Coral USB Accelerator datasheet v1.4: "4 TOPS total peak performance (int8)". The Edge TPU has no sparsity mode, so this is already the dense figure.
BW 0.5 GB/s — Google publishes no bandwidth for this device. This is the HOST LINK, not memory: USB 3.0 SuperSpeed is 5 Gbit/s, and 8b/10b line coding leaves 5e9 x 0.8 / 8 = 500 MB/s of payload. Real bulk transfer lands nearer 350-450 MB/s. The Edge TPU's own ~8 MB of on-chip SRAM has no published figure.
Power 2 W — Coral datasheet v1.4: "4 trillion operations per second (4 TOPS), using 2 watts of power - that's 2 TOPS per watt". The 2.5 W published until D-256 was neither of Google's two numbers and made this page's own TOPS/W tile read 1.60 where Google prints 2.00. Peak port draw is 5 V x 900 mA = 4.5 W.
- Raspberry Pi 5 8GB
TOPS 0.61 — The Pi 5 has NO NPU and Raspberry Pi publishes no TOPS. The 2.4 published until D-256 was exactly the CPU clock in GHz. Derived NEON ceiling: 4 x Cortex-A76, 2 x 128-bit SIMD pipes, SDOT = 16 INT8 MACs per instruction: 4 x 2 x 16 x 2 x 2.4 GHz = 614 GOPS.
BW 17.0 GB/s — Raspberry Pi documentation: "A 32-bit LPDDR4X memory interface provides up to 17 GB/s of memory bandwidth". The product brief's LPDDR4X-4267 part confirms it: 4 bytes x 4267 MT/s / 1000 = 17.07 GB/s.
Power 12 W — Raspberry Pi publishes no TDP, only a current budget: 800 mA typical bare-board and 1.6 A maximum USB peripheral draw at 5 V. 5 x 0.8 = 4.0 W board, plus 8.0 W of USB allowance = 12 W. The official PSU is rated 5 V / 5 A = 25 W.
- LattePanda 3 Delta
TOPS 0.31 — No vendor or community source states any TOPS for the N5105 — the 1.2 published until D-256 reproduces as 24 EU x 8 lanes x 2 (FMA) x 0.8 GHz x 4 (INT8 DP4A) = 1.23 TOPS, but DP4A arrived with Xe-LP/Gen12 and this is Gen11 graphics, so that 4x does not exist here. Derived instead at the FP32 rate: 24 x 8 x 2 x 0.8 GHz = 307 GFLOPS = 0.31 TOPS. The Gen11 FP16 path would give at most 0.61.
BW 23.5 GB/s — Intel ARK publishes no bandwidth row for the N5105. Derived from its Maximum Memory Speed 2933 MHz over a 64-bit (2 x 32 LPDDR4x) bus: 2933 x 8 / 1000 = 23.5 GB/s. The 25.6 published until D-256 needs 3200 MT/s, which this SoC does not support. Bus width is not vendor-stated; 128-bit would double this.
Power 10 W — Intel ARK, Celeron N5105: TDP 10 W, with no configurable-TDP-up row. LattePanda's own page also says 10 W. The 12 W published until D-256 was the board's 12 V input rail, not a power figure.
- ESP32-S3 DevKitC
TOPS 0.0154 — Espressif publishes speedup ratios, never an ops/s figure. Derived from the ESP32-S3 TRM: the 8-bit ALU "contains 16 multipliers and is able to make up to 16 multiplications and accumulation in one instruction", so 16 x 2 x 240 MHz = 7.68 GOPS per core, 15.36 GOPS dual-core. The 0.15 TOPS published until D-256 is ~10x above that ceiling — it would need 312 MACs/cycle.
BW 0.16 GB/s — Octal PSRAM at the datasheet-rated 80 MHz, which Espressif documents as DDR: 8 bits x 2 x 80e6 / 8 = 160 MB/s. The 0.08 published until D-256 dropped the DDR factor. Internal SRAM is far faster (~3.8 GB/s) and only the -N8R8 style variants carry octal PSRAM at all.
Power 0.36 W — Espressif publishes no TDP, only current tables. Datasheet Table 5-9, 240 MHz, dual core running 128-bit data-access instructions — the SIMD path this row's TOPS rests on — gives 107.9 mA at 3.3 V = 0.36 W. The 1.0 W published until D-256 was the Wi-Fi transmit peak, not a compute figure.
Anatomy of Edge SBC & Accelerator Systems
Deploying computer vision, localized voice models, or vector databases at the edge requires matching model architecture to silicon bottlenecks.
Host System Architecture
x86 boards like the LattePanda 3 Delta run standard Linux kernel builds and full Windows IoT without cross-compilation. ARM boards like Raspberry Pi 5 offer high power efficiency but rely on ARM NEON vector instructions for CPU-side execution.
Dedicated NPU Acceleration
Jetson Orin Nano Super packs 1024 Ampere CUDA cores with Tensor Cores. NVIDIA publishes 67 INT8 TOPS sparse and 33 dense under MAXN_SUPER; this page models dense networks, so 33 is the figure it computes with. Google Coral Edge TPU delivers 4 TOPS INT8 at 2 W via USB 3.0.
Bus Width & Bandwidth Limits
Model size directly determines memory transfer time. LPDDR5 on the Jetson Orin Nano Super yields 102 GB/s bandwidth, while USB 3.0 external accelerators like Coral are constrained by the ~480 MB/s bus transfer rate.
Gear behind this build
Curated single-board computers, accelerators, NVMe storage, and systems engineering references.
$61.00BookDeep Learning (Adaptive Computation and Machine Learning series)
Foundational deep-learning textbook referenced while building itria.
$40.00BookDesigning Machine Learning Systems: An Iterative Process for Production-Ready Applications
ML systems-design reference used while building itria.
$49.50BookHands-On Machine Learning with Scikit-Learn, Keras, and TensorFlow: Concepts, Tools, and Techniques to Build Intelligent Systems
Practical ML reference used while building itria.
$129.99AcceleratorGoogle Coral USB Edge TPU ML Accelerator coprocessor for Raspberry Pi and Other Embedded Single Board Computers
USB Edge TPU for int8 quantized nets — run the same quantized CoreML model sized here and see why int8 cuts RAM bandwidth but needs per-channel scales.
$72.22BookProgramming Massively Parallel Processors: A Hands-on Approach
CUDA/GPU parallel programming text for WebGPU PINN and edge GPU workloads.
$259.99SBCJetson Nano Developer Kit 16G eMMC onboard for AI Machine Learning (4GB RAM 16GB eMMC)
eMMC variant for TinyML deployment — flash int8 quantized CoreML model sized by this calculator and measure flash vs RAM footprint tradeoff.
Prices shown were retrieved from the Amazon Product Advertising API on 19 July 2026 and are indicative only — the price and availability on Amazon at the time of purchase apply.
Build this lab
Edge AI SBC & Hardware Acceleration Stack
LattePanda 3 Delta + Jetson Orin Nano + Coral Edge TPU + fast NVMe SSD — measure x86, ARM CUDA, and TPU INT8 quantization workloads locally on real hardware.
- $435
- $130
- $270
- $260
- $40
Prices shown were retrieved from the Amazon Product Advertising API on 19 July 2026 and are indicative only — the price and availability on Amazon at the time of purchase apply.
Prices shown were checked against the Amazon product listing on 9 August 2026 and are indicative only — the price and availability on Amazon at the time of purchase apply.
Estimated total
$835
Prices from Amazon catalog cache · may change
The Math and Physics of Edge Execution
Understanding the Roofline Model, operational intensity, and thermal dissipation governing embedded NPU hardware.
1. Roofline Bottleneck Model
Execution latency is governed by the maximum of compute execution time and memory transfer time:
If operational intensity is below the machine knee , the system is strictly memory-bound.
2. Thermal Dissipation & Joules per Inference
Electrical power converted into heat energy follows:
Energy per inference dictates battery life in autonomous mobile robotics and field-deployed solar edge nodes.
Core Solver & Benchmarking Code
C++ benchmark harness for computing Roofline latency across edge hardware targets.
// Edge AI Hardware Benchmark Harness (C++ / ONNX Runtime & TensorRT)
#include <iostream>
#include <chrono>
#include <vector>
struct HardwareSpec {
const char* name;
float peakTops; // INT8 / FP16 TOPS
float memBandwidth; // GB/s
float maxTdpWatts; // Thermal Design Power
};
float calculateRooflineLatencyMs(float modelGflops, float modelSizeMb, const HardwareSpec& spec) {
float computeTimeSec = (modelGflops * 1e9f) / (spec.peakTops * 1e12f);
float memoryTimeSec = (modelSizeMb * 1e6f) / (spec.memBandwidth * 1e9f);
// Bottleneck governs execution time
float executionSec = std::max(computeTimeSec, memoryTimeSec);
return executionSec * 1000.0f; // Return ms
}
int main() {
HardwareSpec jetsonOrin = {"Jetson Orin Nano Super", 33.0f, 102.0f, 25.0f};
HardwareSpec coralTpu = {"Google Coral USB TPU", 4.0f, 0.50f, 2.0f};
float yoloGflops = 28.6f; // YOLOv8 Small, one 640x640 frame
float modelMb = 22.4f; // 11.2M params at FP16
std::cout << "Jetson Orin Latency: " << calculateRooflineLatencyMs(yoloGflops, modelMb, jetsonOrin) << " ms\n";
std::cout << "Coral Edge TPU Latency: " << calculateRooflineLatencyMs(yoloGflops, modelMb, coralTpu) << " ms\n";
return 0;
}Export · Soft gate
Export Edge Hardware Benchmark Report
Hardware benchmark suite for edge computing & AI: measure latency, bandwidth, TOPS/Watt, and TDP across LattePanda, Jetson, and Pi 5.
File · edge-sbc-benchmarks.txt
edge-sbc-benchmarks.txttext/plain+ watermark line on free pathFree download adds a small footer:
# Export from makerportal.ai — free watermarked build. Unlock c…Clean export removes footer. Both are generated fresh from your current sim tuning.
Privacy: email stays in your browser localStorage (mp_export_email_edge-sbc-benchmarks) + unlock flag (mp_export_unlock_edge-sbc-benchmarks). If Buttondown username is configured, we also POST to Buttondown (privacy-first mode, no tracking pixels per D-014). See privacy → affiliates & email.
Unlock clean export
Soft gate — no hard paywall, no Clerk. Email stays local unless you explicitly check the newsletter box. Unsubscribe anytime. RSS at /rss.xml.
✓ Lab Pro — clean export on every lab
Your licence unlocks this and every other gated simulator, so there is nothing to enter here. Manage or sign out on the shop page.
✓ Unlocked — clean exports enabled
Stored in mp_export_unlock_edge-sbc-benchmarks. Clean file omits watermark. Re-lock via browser devtools → localStorage.
Frequently Asked Questions
How does x86 CPU performance (LattePanda 3 Delta) compare to ARM + CUDA (Jetson Orin Nano) for edge AI?
The LattePanda 3 Delta uses an Intel Celeron N5105 quad-core x86_64 processor. While x86 shines for legacy Linux software compatibility, desktop OS execution, and Windows IoT enterprise workloads, its integrated UHD graphics ceiling is 24 EU × 8 lanes × 2 × 0.8 GHz ≈ 0.31 TOPS, and Tremont has no VNNI so INT8 does not beat that FP32 rate. By contrast the NVIDIA Jetson Orin Nano Super delivers 33 INT8 TOPS dense (67 sparse) from 1024 Ampere CUDA cores with Tensor Cores — about 100× higher AI throughput on the dense networks this page models.
What is the Roofline Model and why does memory bandwidth limit edge NPU throughput?
The Roofline Model plots achievable performance (GFLOPS) against operational intensity (FLOPs per byte of memory access). Edge neural network accelerators (like Coral Edge TPU or Raspberry Pi 5) are frequently limited not by peak compute execution, but by memory bandwidth. If a model requires reading 50 MB of weights per frame over a 5 GB/s bus, the hardware is strictly memory-bound and cannot exceed 100 FPS (10 ms per frame), regardless of how many TFLOPS the compute engine possesses.
When should I use a USB Coral Edge TPU versus an onboard Jetson Orin NPU?
The Google Coral USB Accelerator is ideal for adding low-power (2 W, per Google's 4 TOPS at 2 TOPS/W) INT8 vision inference to existing host systems (such as a Raspberry Pi or industrial mini PC). However, Coral requires strict 8-bit quantization (post-training quantization or QAT) and only supports specific TensorFlow Lite operations. The Jetson Orin Nano supports FP16, INT8, and INT4 with full TensorRT support for PyTorch, ONNX, LLMs, and complex dynamic graphs.
How do I optimize thermal dissipation for 24/7 edge AI deployments?
At high utilization, boards like the LattePanda 3 Delta (12W TDP) and Jetson Orin Nano Super (25W MAXN) generate significant thermal dissipation ($Q = P_{elec}$). Without active heatsinks and fan cooling, silicon temperature triggers thermal throttling, reducing clock speeds by up to 50% to prevent junction overheating ($T_j > 95^\circ\text{C}$). Passive aluminum enclosures require proper thermal interface pads ($> 5 \text{ W/m}\cdot\text{K}$) and convection fin alignment.
Shareable still
The instrument, captured—not illustrated.
This 16:9 frame is rendered from the real browser instrument above. It is the page's canonical preview for image search, link unfurls, and posts that need to show what the tool actually does.
Download 1280 × 720 JPEG
Continue the experiment
Related instruments
CoreML Model Size & Quantization Calculator
Exact on-device footprint math, no throughput guesswork
PID & MPC Flight Arena
Tune a quadrotor, watch quaternions keep it alive
Agentic Closed-Circuit Lab
GenUI instruments gated by deterministic solvers — Edge SLM proposes, Zod + registry disposes