This blog post is co-athored by Zineb Labrut, Software and Ecosystem Product Manager, Edge AI Business Unit, Adrian Lundell, ML software engineer, Arm

and Eldar Sido, Tech Lead, Edge AI & Product Software, Embedded Processing Business Group, Renasas Electronics

Deploying a PyTorch model on an MCU has traditionally required framework conversions, platform-specific integration and substantial application plumbing. Arm and Renesas are working together to simplify that path. This blog follows a model from PyTorch through ExecuTorch and Arm Ethos-U55 acceleration to a live camera application running on Zephyr on the Renesas RA8P1, where NPU offload delivers a 17.5x speed-up over CPU-only inference.

The result is a practical, open-source starting point that developers can run on silicon and extend with their own models.

1. Why open edge AI matters

AI is moving closer to where data is generated. Running AI at the edge can reduce latency and data movement and allow devices to react locally to sensor inputs. Deploying AI models in embedded products, however, requires a software path that connects model development to efficient execution and the broader device application.

Open-source software helps connect those layers. PyTorch provides the model-development environment, ExecuTorch extends the PyTorch workflow to edge devices, and Zephyr provides the real-time operating system (RTOS) services and drivers needed to support the application. Arm contributes across these ecosystems to help developers move from model development to efficient execution on Arm-based platforms.

2. Bringing edge AI to life on the Renesas RA8P1

The Renesas RA8P1 brings these technologies together on a single MCU. It combines an Arm Cortex-M85 delivering over 7,300 CoreMark, an Arm Ethos-U55 neural processing unit (NPU) delivering up to 256 giga operations per second (GOPS), and the peripheral interfaces needed for a complete Edge AI application.

Running inference is only one part of that application. Devices also need to capture data from cameras or sensors, process it through a model and act on the results. The RA8P1 supports this with MIPI CSI-2 and parallel camera inputs, I2S and PDM audio interfaces, and display connectivity, so developers can connect AI inference to real-world inputs and outputs on a single MCU.

Figure 1: RA8P1 system block diagram

The two processors share the work. The Ethos-U55 executes supported inference operations, while the Cortex-M85 handles application control and pre- and post-processing, accelerated by Arm Helium vector extensions (MVE). Together, they support vision, voice and real-time analytics in applications such as industrial monitoring, smart-home devices and camera-based systems. You can compare CPU-only and NPU-accelerated performance across models in the RUHMI Model Zoo Explorer.

The rest of this blog post walks through an example on the RA8P1: preparing a PyTorch model with ExecuTorch and integrating it into a Zephyr-based camera application.

3. Why Zephyr for edge AI

Once a model is prepared for the target hardware, it must be integrated into the wider embedded application. A deployable Edge AI application also needs camera capture, pre-processing, display output, memory management and coordinated application threads.

Zephyr is a modular, open-source RTOS that provides APIs and software components for building these applications. Developers can select software features through Kconfig and describe target hardware through devicetree.

Because Zephyr supports a broad range of Arm Cortex-M devices, the RA8P1 example can also serve as a reusable starting point for other targets. Its common APIs and reusable software components help developers build applications across supported Arm-based platforms without starting the software integration from scratch. Board-specific drivers, accelerator integration and memory requirements must still be validated for each target.

Zephyr’s contributor and commit activity increased from 2019 to 2025, as shown below. For developers choosing a platform for a long-lived Edge AI product, this activity provides one indicator of an active ecosystem supporting the RTOS.

Figure 2: Zephyr contributor and commit growth, 2019–2025. Source: Renesas analysis of Git commit history on each project's default branch, 2019–2025 (performed September 2026).

Renesas also contributes to the Zephyr ecosystem. As a Platinum member of the Zephyr Project, Renesas contributes board and driver support upstream and supports more than 60 boards across the RA, RX and RZ families. On EK-RA8P1, that support includes the camera, display, 2D graphics and external-memory drivers used by this example. Developers can therefore assemble the application through standard Zephyr APIs instead of first creating the platform drivers themselves.

4 Take a PyTorch model to an embedded device with ExecuTorch

Developers building embedded AI applications often start with a model in PyTorch, but deployment on an MCU has traditionally involved additional framework conversions, intermediate formats and target-specific integration. These extra steps add work and can make it harder to preserve the behavior of the original model through deployment.

ExecuTorch is the open-source PyTorch runtime for edge devices. It provides a PyTorch-native path for preparing a model for the target and executing it with a lightweight runtime designed for resource-constrained devices.

The flow starts with a PyTorch model. The model is exported for deployment, optimized for the target, and serialized into an ExecuTorch program (.pte), which is then loaded by the ExecuTorch runtime on the embedded target. All intermediate steps are done in the same eager-mode executable exir format as the original exported program, creating a unified development experience across the full lowering flow. With tools such as Model Explorer, ETRecord and ETDump, ExecuTorch provides both an out-of-the-box deployment option and a framework for advanced platform-specific optimizations.

Figure 3: ExecuTorch model preparation and runtime

ExecuTorch also supports backend delegation, allowing supported parts of the model to target specialized accelerators and optimized kernels. On the RA8P1, this provides the bridge from the PyTorch model to the Arm Ethos-U55 NPU.

5. Prepare a model for Ethos-U with ExecuTorch

Arm Ethos-U is a family of NPUs designed to accelerate neural network inference in embedded and edge systems-on-chip (SoCs). Integrated alongside a Cortex-M or Cortex-A CPU, Ethos-U operates as a dedicated co-processor. The CPU runs the application and runtime and initiates NPU execution, while Ethos-U executes the delegated neural network workloads. Operators that are not delegated to the NPU may run on the CPU, when supported by the configured runtime and backend, enabling CPU execution and NPU acceleration to work together. In such cases, the CMSIS-NN-backend for Cortex-M and the XNNPack-backend for Cortex-A can be used in combination with the Ethos-U backend for full acceleration.

The Ethos-U family addresses a range of Edge AI performance requirements. Ethos-U55, integrated in the Renesas RA8P1 used in this example, accelerates supported neural network workloads, including convolutional neural networks (CNNs). Ethos-U65 extends the family to higher-performance systems, while Ethos-U85 scales performance further to support more demanding workloads, including transformer-based networks.

Ethos-U is supported by the Arm Vela compiler, which compiles neural network workloads for efficient execution on the NPU. Vela accounts for the target Ethos-U configuration and memory system to optimize execution, memory usage, and data movement, and generates the command stream executed by the NPU. Vela is integrated into multiple ML software flows, including TensorFlow Lite and PyTorch through ExecuTorch.

In this example, ExecuTorch provides the path from a PyTorch model to Ethos-U55 acceleration on the Renesas RA8P1. As shown in the figure below, the model is exported from PyTorch and quantized to INT8 weights and activations. The ExecuTorch Ethos-U backend then lowers supported parts of the quantized model to TOSA (Tensor Operator Set Architecture), a standard intermediate representation for tensor operations.

Vela takes the TOSA representation and compiles it for the target Ethos-U configuration, in this case the Ethos-U55 on the RA8P1 — optimizing the delegated operations for efficient execution and generating the command stream for the NPU. This compilation is integrated into the ExecuTorch model preparation flow, and the resulting program is packaged into an ExecuTorch .pte file ready for integration with the target application.

Figure 4: PyTorch model to Ethos-U55 firmware asset

6. Run ExecuTorch on the Renesas RA8P1

The EK-RA8P1 example is structured to shorten the path from a prepared model to execution on silicon. Developers set up a Zephyr workspace with the ExecuTorch module, add the compiled ExecuTorch program (.pte), build the application for EK-RA8P1 and flash it to the board. The accompanying guide provides the exact commands, while this blog focuses on how the model, runtime, accelerator, and Zephyr application fit together.

The resulting reference implementation provides a starting point for testing supported models on the RA8P1, examining runtime behavior and extending the application without rebuilding the full integration from scratch.

Figure 5: Online Zephyr application flow

7. From inference to a camera-based application

The reference application captures live camera frames, performs the required pre-processing on the Cortex-M85, runs image classification through ExecuTorch with Ethos-U55 acceleration, and presents the result on the display through Renesas-supported Zephyr drivers.

The diagram below shows the vision AI application running on EK-RA8P1.

Figure 6: EK-RA8P1 vision AI system diagram

The table below compares the same MobileNetV2 0.5 image-classification application built for CPU-only execution on the Cortex-M85 with Helium and with inference delegated to the Ethos-U55. All values were measured on-device on EK-RA8P1. Offloading inference to the NPU cuts inference time from 403 ms to 23 ms and reduces end-to-end latency from camera capture to display from 463 ms to 85 ms, sustaining around 12 FPS.

Table 1: CPU-only and Arm Ethos-U55 NPU performance comparison on the Renesas RA8P1

Tested with ExecuTorch v1.4.1, Zephyr v4.4 and Arm Vela v5.1.0 on EK-RA8P1 (Cortex-M85 at 1 GHz, Ethos-U55 at 500 MHz). Input: 640 × 480 camera frames, resized to 224 × 224 for MobileNetV2. Output: 1024 × 600 display.

This closes the loop from model development to a working embedded application: start with a PyTorch model, prepare it with ExecuTorch for Ethos-U55 acceleration, and integrate it with live camera input, application logic and display output through Zephyr. Developers can use the working RA8P1 application as a starting point, replace the included model with another supported model, and extend the pipeline for their own Edge AI product.

8. Resources and next steps

Get started with the ready-to-run EK-RA8P1 sample and its build guide, then replace the included model with your own delegated ExecuTorch program. From there, developers can extend the camera pipeline, explore additional models and contribute improvements upstream across the Renesas, Arm, PyTorch and Zephyr ecosystems