NVIDIA Jetson Nano Overview
- NVIDIA Jetson Nano is an embedded single-board computing platform with a quad-core ARM CPU and 128-core GPU, designed for efficient edge AI deployment.
- Researchers leverage its optimized CUDA, TensorRT, and containerized software stack to achieve real-time inference in vision, robotics, and biosignal acquisition.
- The platform serves as a flexible baseline in comparative studies, where its performance depends on memory, thermal management, and software integration.
NVIDIA Jetson Nano (NJn) is an embedded single-board computing platform that appears in the research literature as a low-cost, low-power host for edge inference, embedded vision, robotics, biosignal acquisition, and comparative accelerator studies. Reported configurations combine a quad-core ARM Cortex-A57-class CPU with a 128-core Maxwell GPU and 4 GB LPDDR4 memory, while the surrounding software ecosystem is typically organized around Ubuntu/JetPack, CUDA-enabled frameworks, TensorFlow, PyTorch, and TensorRT deployment paths (Rehman et al., 2021, Farooq et al., 2022, Gamage et al., 30 Apr 2026, Magalhães et al., 2022).
1. Platform profile and hardware variants
Published studies describe Jetson Nano primarily as a heterogeneous CPU–GPU embedded platform rather than as a narrowly specialized accelerator. Reported hardware descriptions include a quad-core ARM Cortex-A57 CPU at 1.43 GHz, a 128-core Maxwell GPU, and 4 GB 64-bit LPDDR4 memory with 25.6 GB/s bandwidth; some papers additionally state 5 W–10 W thermal design power or 5 V 2 A / 5 V 4 A board-power options (Rehman et al., 2021, Farooq et al., 2022). At the board level, the literature reports HDMI, DisplayPort, USB 3.0, micro-USB, Gigabit Ethernet, a 40-pin expansion header, and a MIPI CSI camera connector, alongside interfaces such as GPIO, I2C, I2S, SPI, and UART (E, 2021, Rehman et al., 2021).
The platform is not represented by a single fixed hardware instantiation in the literature. Papers refer variously to the Jetson Nano Developer Kit, the 2 GB Developer Kit, the 4 GB Developer Kit, and the B01 module integrated with a Yahboom development board (Magalhães et al., 2022, Murray-Hill et al., 2023, Gamage et al., 30 Apr 2026). This variation matters because several studies tie deployment feasibility directly to available memory: the 2 GB and 4 GB variants are treated differently in agricultural RetinaNet experiments, where both Nano versions failed the target TF-TRT deployment because of memory and device limitations (Magalhães et al., 2022).
Researchers also use the board as a host for non-vision peripherals. In the JNEEG work, the Nano is the system computer for an EEG shield built around a Texas Instruments ADS1299 ADC connected over SPI; the shield preserves access to the GPIO40 header and still allows a cooling fan connection (Rakhmatulin, 2023). In surveillance and streaming work, the device is described as a small computer for image and video processing applications running in an ARM64v8 Linux environment (Murray-Hill et al., 2023).
2. Software environment and deployment pathways
The software stack around Jetson Nano is diverse but strongly centered on NVIDIA’s deployment toolchain. Explicitly reported environments include JetPack 4.5.1 with L4T 32.5.1, JetPack 4.6.1 with the NVIDIA L4T R32.7.1 PyTorch container, JetPack 4.2, Ubuntu 18.04.06 LTS, Ubuntu 20.04, and ROS2 Dashing in robotics-oriented setups (Farooq et al., 2022, Swaminathan et al., 2024, Lofqvist et al., 2020, Gazzard et al., 2024, Varposhti et al., 2024). Containerized deployment is also reported, including Docker-based packaging for SSD MobileNetV2 face detection on the Developer Kit (Rehman et al., 2021).
A recurring deployment pattern is framework-level training followed by inference-oriented conversion. One benchmark study uses the path PyTorch ONNX TensorRT, with explicit CUDA device-memory allocation, host-to-device transfer, asynchronous execution, and stream synchronization during inference (Swaminathan et al., 2024). Another benchmarks TensorFlow, TF-TRT, TensorRT, and TensorFlow Lite separately on the Nano, including TensorFlow-to-ONNX conversion for the standalone TensorRT path (Baller et al., 2021). UAV detection work uses PyTorch 1.8.0 for training, ONNX export, and TensorRT 7.1.3 with FP16 serialization for on-device deployment (Zhou et al., 2022). Thermal-imaging experiments similarly use TensorRT to optimize YOLOv5 inference on the Nano (Farooq et al., 2022).
Despite this relatively coherent ecosystem, reproducibility is often incomplete. Multiple papers omit JetPack version, CUDA version, cuDNN version, TensorRT version, exact clocks, or power-mode configuration, even when they claim real-time or edge suitability (E, 2021, Rakhmatulin, 2023, Gazzard et al., 2024). A plausible implication is that many Nano studies are stronger as deployment case studies than as fully controlled systems benchmarks.
3. Inference performance and optimization behavior
Reported Jetson Nano performance is highly workload-specific. Cross-paper comparisons are therefore best read as exemplars of operating regimes rather than as a unified benchmark.
| Workload | Conditions | Reported Nano result |
|---|---|---|
| RT-MonoDepth-S | TensorRT FP16, batch size 1, 10 W, | 30.5 FPS (Feng et al., 2023) |
| FasterX-Nano | TensorRT FP16, | 23.47 FPS, 42.60 ms (Zhou et al., 2022) |
| YOLOv5n | COCO2017, CPU+GPU | 11.9 FPS, 0.159 mWh/frame (Machado et al., 2022) |
| Thermal YOLOv5 small model | TensorRT, 402 images, | 11 fps (Farooq et al., 2022) |
| WeedScout YOLOv8 | 5-second blackgrass video | 83.97 s mean inference time (Gazzard et al., 2024) |
| SRNN gesture recognition | best reported operating point | 155 frame/s at 80% accuracy, 1.5 W (Varposhti et al., 2024) |
The dominant systems-level lesson is that the deployment backend often matters as much as the network architecture. In a practice-oriented YOLOv4-tiny study, a Keras-based path yielded 4–5 FPS, Darknet with cuDNN 12–14 FPS in the body text and 12–15 FPS in the table, TensorRT 25 FPS, DeepStream about 25 FPS, and tkDNN 30–35 FPS on Jetson Nano (Ildar, 2021). A broader TensorRT study reports that optimized models on Nano were on average 7.011× faster than their pre-optimization baselines, with especially large gains for MobileNet V2 and ShuffleNet V2 (Swaminathan et al., 2024). DeepEdgeBench reports MobileNetV2 at 685.490 s for 5000 images in native TensorFlow, 103.142 s with TF-TRT, and 118.737 s with TensorRT, again showing large stack-dependent speed variation (Baller et al., 2021).
The platform is not uniformly real-time. Some models clearly reach practical frame rates, as in RT-MonoDepth-S at 30.5 FPS and FasterX-Nano at 23.47 FPS (Feng et al., 2023, Zhou et al., 2022). Other deployments do not: WeedScout’s YOLOv8 took 83.97 s on average to process a 5-second video, and YOLO-NAS took 223.80 s, which the authors explicitly treat as non-real-time (Gazzard et al., 2024). Similarly, retinal fundus classification on Jetson Nano 2GB is reported at 2.19 images/s for the best student model, with a claimed 5.41 images/s for a quantized version; the paper itself warns that the quantization result may be unreliable because the model sizes were the same and the apparent speedup may reflect GPU warm-up rather than saved quantization state (Yilmaz et al., 23 Jun 2025).
Memory pressure is a recurrent limiting factor. RetinaNet ResNet-50 could not be assessed on Jetson Nano 2 GB or 4 GB because the model could not be converted and compiled into TF-TRT on those devices (Magalhães et al., 2022). In space-oriented aerial-image detection, the Nano required 4 GB of swap, and image scaling was necessary to obtain a 100% runnable dataset for large DOTA images (Lofqvist et al., 2020). These results indicate that Jetson Nano’s GPU advantage is contingent on model size, representation size, and memory behavior rather than on raw FLOP counts alone.
4. Research applications and domain-specific roles
Jetson Nano is used most extensively in computer-vision deployment studies. It appears in face detection and identity-labeled SSD MobileNetV2 experiments, thermal object detection for vehicular assistance, monocular depth estimation, UAV object detection, blackgrass detection and mapping, retinal fundus classification, and gesture recognition from event-derived inputs (Rehman et al., 2021, Farooq et al., 2022, Feng et al., 2023, Zhou et al., 2022, Gazzard et al., 2024, Yilmaz et al., 23 Jun 2025, Varposhti et al., 2024). In this literature, the board functions both as a low-cost inference target and as a lower-end baseline against Xavier NX, Orin Nano, TPUs, VPUs, FPGAs, and neuromorphic devices.
Several studies are explicitly application-specific rather than platform-general. The FasterX paper redesigns YOLOX for small-object UAV detection on edge GPUs and reports 23.47 FPS on Nano at , emphasizing that a naive four-head YOLOX design causes severe latency inflation on the board (Zhou et al., 2022). RT-MonoDepth and RT-MonoDepth-S are designed around embedded latency rather than pruning and reach 18.4 FPS and 30.5 FPS, respectively, on Nano using TensorRT FP16 at (Feng et al., 2023). The thermal-imaging study validates only the small YOLOv5 variant on Nano because of memory and computational limits, then uses TensorRT to reach 11 fps on thermal inputs (Farooq et al., 2022).
The board also appears outside conventional vision. In JNEEG, Jetson Nano becomes an EEG/BCI acquisition and intended edge-processing platform: the ADS1299 front-end communicates with the Nano over SPI, the current implementation supports 8 EEG channels with extension to 32, reported EEG sampling is 250–1000 Hz, and the hardware validation reports 1.5 µV peak input noise together with 115 dB common-mode rejection from 0–50 Hz (Rakhmatulin, 2023). The paper’s key contribution is hardware integration and signal-quality validation; it explicitly does not yet benchmark a full on-device CNN pipeline.
As a comparative baseline, Nano increasingly functions as the lower-cost, lower-throughput member of the Jetson family. In cross-platform ANN-versus-SNN object detection, Jetson Nano B01 runs ANN baselines with TensorRT FP16 at roughly 19–23 samples/s, with total energy per inference in the 159–189 mJ range depending on model and dataset, while Jetson Orin Nano is much faster and Loihi 2 is much lower energy (Gamage et al., 30 Apr 2026). This suggests that, within more recent embedded-AI literature, Jetson Nano is often treated less as a frontier platform than as a deployment floor or low-end reference point.
5. Power, thermal behavior, and security exposure
Power and energy measurements are a major theme in the Nano literature, but the metrics vary. One YOLOv5 study defines an energy-per-frame quantity as
with results reported in mWh/frame (Machado et al., 2022). Under that methodology, YOLOv5n is the most favorable tested model on Nano: 11.9 FPS and about 0.159 mWh/frame on COCO2017 in CPU+GPU mode, versus 0.4 FPS and about 2.183 mWh/frame in CPU-only mode; YOLOv5x drops to 0.9 FPS and about 2.562 mWh/frame (Machado et al., 2022). DeepEdgeBench, using a different setup, reports Nano idle power of 1.391 W with LAN and 0.903 W without LAN, the lowest idle power among the Linux-class SoCs in that study (Baller et al., 2021).
Thermal management is explicitly documented in the thermal-imaging paper. With no external fan, the reported Jetson Nano values were AO thermal zone 65.50 °C, CPU 55 °C, GPU 52 °C, and PLL 53.50 °C; with an external 5 V fan mounted on the heatsink, the corresponding values dropped to 45.50 °C, 33 °C, 33 °C, and 33 °C, respectively, which the authors summarize as nearly 30% temperature reduction (Farooq et al., 2022). Conversely, some studies report power modes without clear performance benefit: in facial expression recognition, average latency was 1.92 ms in low-power mode and 1.93 ms in Max-N/high-power mode, while average dynamic power increased from 1.03 W to 2.37 W (Mohammadi et al., 2023).
Security-oriented work exposes another dimension of the platform. A side-channel study shows that the Jetson Nano GPU leaks enough electromagnetic information during TensorRT CNN inference for a 1D-CNN classifier to distinguish 15 architectures at 99% test accuracy from EM traces (Horvath et al., 2024). A separate secure-video-streaming comparison reports 30 fps at on Nano, both with and without authentication, but classifies the Nano implementation as unsafe because the secure key was exposed to memory rather than protected in dedicated hardware logic (Murray-Hill et al., 2023). Taken together, these studies challenge the assumption that model architecture confidentiality or key secrecy follows automatically from deploying on an embedded GPU board.
6. Recurring limitations and research interpretation
A persistent feature of the Jetson Nano literature is uneven reporting quality. Some papers provide precise deployment conditions—such as 10 W mode, FP16 TensorRT, batch size 1, 1000 warm-up runs, and 5000 timing iterations for RT-MonoDepth (Feng et al., 2023)—whereas others omit JetPack version, exact inference precision, clock configuration, memory footprint, or whether preprocessing and postprocessing are included in latency (E, 2021, Gazzard et al., 2024, Yilmaz et al., 23 Jun 2025). This unevenness complicates cross-paper synthesis.
Another recurring limitation is the difference between hardware feasibility and end-to-end edge-AI validation. JNEEG proves that Jetson Nano can host a low-noise EEG shield and perform acquisition locally, but it does not yet demonstrate a completed on-device CNN or motor-imagery benchmark (Rakhmatulin, 2023). The retinal distillation paper demonstrates a strong teacher–student compression pipeline and some direct Nano throughput numbers, but not a fully specified production deployment path (Yilmaz et al., 23 Jun 2025). The WeedScout study shows successful field-oriented deployment on Nano, yet also shows that the reported implementation is far from real-time (Gazzard et al., 2024).
The term “real-time” therefore has to be interpreted narrowly and contextually in Nano research. It is justified for some optimized small-to-moderate models, such as RT-MonoDepth-S or FasterX-Nano (Feng et al., 2023, Zhou et al., 2022), but it is not a general property of the platform. A plausible implication is that Jetson Nano is best understood as an embedded GPU platform whose practical value depends on careful co-design among model scale, memory footprint, runtime stack, and duty cycle. In the contemporary literature, it remains an important reference platform precisely because it makes these trade-offs visible.