Arduino Portenta X8 Guide: Linux, STM32H747, Containers, RPC, GPIO and Industrial I/O

The Arduino Portenta X8 is not a conventional microcontroller board.

It is an industrial System-on-Module that combines:

The important idea is that these processors are not simply independent boards placed next to each other.

Arduino designed the X8 so that Linux handles high-level computing while the STM32H747 provides deterministic microcontroller I/O and real-time control.

Portenta X8 Architecture at a Glance

Subsystem	Hardware	Typical role
Linux processor	NXP i.MX 8M Mini	Linux, containers, networking, databases, Python, edge applications
Linux CPU cores	4 × Cortex-A53 up to 1.8 GHz	Application processing
i.MX auxiliary core	Cortex-M4 up to 400 MHz	Reserved/future low-power or real-time use in Arduino’s current architecture
Real-time MCU	STM32H747	I/O mediation and Arduino real-time control
STM32 M7	Cortex-M7 up to 480 MHz	Arduino firmware bridge between Linux and STM32 peripherals
STM32 M4	Cortex-M4 up to 240 MHz	User Arduino sketch / deterministic real-time tasks
Linux RAM	2 GB LPDDR4	Operating system and applications
Linux storage	16 GB eMMC	Linux filesystem, containers, application data
Wireless	Murata 1DX	Wi-Fi and Bluetooth
Security	NXP SE050C2	Keys, credentials and hardware-backed cryptography

The i.MX 8M Mini Runs Linux

The main application processor is the:

with:

This is a Linux-capable MPU rather than a conventional Arduino microcontroller.

It is suitable for:

• Python applications;
• databases;
• web servers;
• MQTT brokers and clients;
• containerised services;
• edge analytics;
• machine-learning inference;
• network gateways;
• industrial protocol conversion.

2 GB LPDDR4 RAM

The Linux processor has:

which is several orders of magnitude more application memory than a normal Arduino-class MCU.

This makes it practical to run:

• multiple Linux services;
• Docker containers;
• Python packages;
• larger networking stacks;
• databases;
• local web applications.

16 GB eMMC Storage

The X8 includes:

connected to the i.MX 8M Mini.

This stores:

• the Linux operating system;
• container images;
• application files;
• logs;
• configuration;
• local databases.

This is very different from the relatively small Flash storage used by normal MCU firmware.

Yocto-Based Linux

Portenta X8 ships with a:

preloaded onboard.

Yocto is a framework for creating embedded Linux distributions from:

• recipes;
• layers;
• packages;
• board-support metadata.

The system is therefore designed more like an industrial embedded Linux product than a desktop Raspberry Pi installation.

Docker Container Support

A major X8 feature is:

which allows applications to be packaged with their:

• runtime;
• libraries;
• dependencies;
• configuration.

The Linux base system can remain stable while application services run in isolated containers.

You Do Not Need a Paid Subscription to Run Containers

Arduino explicitly states that users can:

without a subscription.

The optional commercial service adds fleet-level functions such as:

• secure OS maintenance;
• fleet monitoring;
• managed OTA updates;
• large-scale device management.

Portenta X8 Manager

For professional fleets, Arduino offers:

with services developed around the Foundries.io infrastructure.

This is aimed at:

• commercial deployments;
• remote fleets;
• security maintenance;
• controlled application rollout;
• OTA management.

The STM32H747 Is Not Used Like a Normal Portenta H7

The second major processor is the:

which contains:

On a normal Portenta H7, both cores can be used directly as application processors.

On Portenta X8, the architecture is different.

The STM32 M7 Is the Linux I/O Bridge

Arduino runs custom firmware on the:

which is normally invisible to the user.

Its role is to:

and mediate communication between Linux and the real-time Arduino side.

The User Arduino Sketch Runs on the STM32 M4

The normal user-programmable real-time core is:

Arduino sketches uploaded through the Arduino environment run on this M4 core.

This is ideal for:

• motor control;
• fast sensor acquisition;
• precise PWM;
• time-critical state machines;
• industrial I/O;
• deterministic communication.

Do Not Confuse the Two Cortex-M4 Cores

Portenta X8 actually contains two different Cortex-M4 processors:

When Arduino documentation talks about uploading an Arduino sketch to:

it normally means the STM32H747 M4.

Traditional Portenta H7 Dual-Core Operation Is Not the X8 Model

Because the STM32 M7 is used as the Linux-to-peripheral mediator, Portenta X8 does not use the STM32H747 in the same traditional:

dual-core pattern as Portenta H7.

The normal architecture is:

How M4 Sketch Uploading Works

Arduino’s current X8 documentation describes a Linux service named:

which watches for an updated Arduino M4 firmware image.

It then uses:

to program the STM32H747 M4.

This means the Linux system participates directly in the Arduino upload process.

Linux and Arduino Can Exchange Data

The X8 supports:

communication between:

• Linux applications;
• the STM32 bridge firmware;
• the user M4 sketch.

MessagePack-RPC

Arduino uses:

for efficient structured data exchange between Linux and the Arduino side.

This is useful when a Linux program needs to:

• read a sensor value from the M4;
• change a motor-control setpoint;
• request I/O state;
• send configuration data;
• receive real-time events.

m4-proxy

On the Linux side, Arduino documentation identifies:

as the service that transfers data between Linux and the STM32 Arduino environment.

The application architecture can therefore look like:

Python + Arduino Is a Natural X8 Pattern

A common design is:

The two parts exchange only the data they need.

Why Not Do Everything in Linux?

Linux is powerful but not normally hard real-time.

The scheduler, memory management and background services can introduce timing jitter.

For tasks such as:

• motor commutation;
• microsecond pulse timing;
• fast deterministic sampling;
• safety state machines;
• precise industrial I/O;

the STM32 M4 is a more appropriate execution environment.

Why Not Do Everything on the STM32?

The reverse is also true.

Implementing:

• large databases;
• web applications;
• containerised services;
• complex TLS stacks;
• Python analytics;
• Linux packages;

on a microcontroller would be unnecessarily difficult.

Linux Can Access Board Peripherals

The STM32 M7 firmware maps Portenta peripherals into the Linux environment.

This allows Linux applications to work with board I/O without manually reimplementing every STM32 driver.

Depending on the interface and software stack, Linux can interact with:

• GPIO;
• I2C;
• SPI;
• UART;
• ADC-related interfaces;
• PWM;
• carrier-board peripherals.

High-Density Connectors Are the Real Expansion Interface

Like other Portenta modules, X8 has two:

on the underside.

These expose high-speed and industrial interfaces far beyond what fits on the MKR-style side headers.

Interfaces Available Through the High-Density Connectors

Arduino’s current X8 datasheet lists access to:

with a separate ADC reference available through the carrier interface.

Gigabit Ethernet

The i.MX 8M Mini includes a:

and the X8 exposes the Ethernet interface through its high-density connector.

A carrier board is required to provide the physical RJ45 connector and associated hardware.

Portenta Breakout and Gigabit Ethernet

The Portenta Breakout carrier exposes:

when used with Portenta X8.

This is an important distinction from Portenta H7’s 10/100 Ethernet implementation.

Wi-Fi and Bluetooth

The X8 includes a:

wireless module based on the Cypress CYW4343W.

Arduino documents:

under the embedded Linux software stack.

Wireless Is Connected to the Linux Processor

The Murata module communicates directly with the i.MX 8M Mini through:

so networking belongs naturally to the Linux side of the system.

USB-C

The board’s USB-C interface supports:

• High-Speed USB;
• host mode;
• device mode;
• DisplayPort output;
• USB Power Delivery support.

This allows X8 to behave much more like an embedded computer than a conventional Arduino board.

Display and Camera Interfaces

The i.MX 8M Mini includes multimedia interfaces such as:

which are exposed through the Portenta carrier architecture.

This enables applications such as:

• industrial HMIs;
• camera gateways;
• machine-vision systems;
• edge video processing.

Hardware Video Acceleration

The i.MX 8M Mini includes multimedia acceleration for formats including:

• H.264;
• H.265 / HEVC;
• VP8;
• VP9.

Arduino’s datasheet lists:

depending on codec and direction.

GPU

The i.MX 8M Mini also includes:

for graphical Linux applications.

PCI Express

The high-density connector exposes:

from the i.MX 8M Mini.

This is particularly useful on larger carrier boards for:

• cellular modems;
• specialised networking hardware;
• industrial expansion;
• storage or communication modules.

Portenta Max Carrier

The Portenta Max Carrier turns X8 into a much more complete edge computer.

It exposes features such as:

• Gigabit Ethernet;
• Mini PCIe;
• RS-232;
• RS-422;
• RS-485;
• audio input/output;
• cellular connectivity options;
• LoRa connectivity;
• battery management.

Portenta Hat Carrier

The Hat Carrier adds:

• Raspberry Pi-style 40-pin HAT compatibility;
• CAN FD transceiver;
• Ethernet;
• microSD;
• USB;
• camera connector;
• analogue and digital I/O.

This is useful when migrating existing Raspberry Pi HAT hardware into a Portenta platform.

Portenta Mid Carrier

The Mid Carrier targets industrial and robotics applications with access to:

• Mini PCIe;
• CAN;
• Ethernet;
• microSD;
• USB;
• camera;
• display;
• analogue I/O.

SE050C2 Secure Element

The X8 includes an:

hardware security device.

Arduino documents capabilities including:

• RSA;
• ECC;
• AES;
• 3DES;
• HMAC;
• SHA family hashing;
• credential storage;
• TPM-related functionality.

Hardware-Backed Device Identity

The secure element allows credentials to remain inside dedicated hardware rather than being stored as ordinary files in the Linux filesystem.

This is useful for:

• cloud authentication;
• fleet identity;
• certificate storage;
• secure provisioning.

Secure Boot and Managed Updates

The overall X8 platform is designed for:

• verified embedded Linux images;
• containerised applications;
• hardware-backed keys;
• OTA updates;
• fleet management.

This makes the board more suitable for long-lived industrial deployments than a simple hobby Linux SBC with an SD card.

Example Architecture: Industrial Gateway

Example Architecture: Machine Vision

Example Architecture: Predictive Maintenance

Common Mistake 1: Treating X8 Like Portenta H7

The STM32H747 is present, but its M7 core is normally occupied by Arduino’s Linux-peripheral bridge firmware.

The user real-time sketch normally runs on:

Common Mistake 2: Thinking the i.MX M4 Is the Arduino Core

The i.MX 8M Mini also includes a Cortex-M4, but Arduino currently reserves it for future use.

The normal Arduino sketch target is the:

Common Mistake 3: Trying to Run Real-Time Control Entirely in Linux

Linux is excellent for high-level applications, but deterministic low-latency control belongs on the STM32 M4.

Common Mistake 4: Trying to Put Linux-Style Workloads on the M4

Databases, Python packages, web servers and containerised services belong on the i.MX 8M Mini.

Common Mistake 5: Assuming the Side Headers Expose the Whole Board

The high-density connectors are essential for:

• Gigabit Ethernet;
• PCIe;
• camera;
• display;
• high-speed USB;
• industrial serial interfaces;
• large carrier-board designs.

Common Mistake 6: Forgetting the Carrier Board

X8 is designed as a System-on-Module.

For many real-world interfaces, choose a suitable carrier such as:

• Portenta Breakout;
• Portenta Max Carrier;
• Portenta Mid Carrier;
• Portenta Hat Carrier;
• a custom carrier PCB.

Common Mistake 7: Assuming Containers Require a Subscription

Running your own Docker containers does not require a paid subscription.

The paid management services are for enterprise fleet features.

Portenta X8 vs Portenta H7

Feature	Portenta X8	Portenta H7
Linux	Yes	No native full Linux
Main application processor	i.MX 8M Mini quad Cortex-A53	STM32H747 Cortex-M7
Linux RAM	2 GB LPDDR4	Not applicable
Linux storage	16 GB eMMC	Not applicable
Real-time Arduino core	STM32H747 M4	M7 and M4 available for application use
Container support	Yes	No Linux Docker environment
Ethernet	Gigabit-capable	10/100 PHY
PCIe	Yes	No native PCIe
Best fit	Linux edge computer + real-time MCU	High-performance microcontroller applications

When Portenta X8 Makes Sense

Choose X8 when the project needs both:

on one compact industrial module.

Typical examples include:

• industrial gateways;
• machine vision;
• edge AI;
• robotics controllers;
• predictive maintenance;
• protocol conversion;
• secure connected machinery;
• containerised industrial applications.

When Portenta X8 Is Overkill

If the project only needs:

• GPIO;
• CAN;
• Wi-Fi;
• sensor acquisition;
• motor control;

without Linux, containers or large applications, a Portenta H7, GIGA R1 or Portenta C33 may be simpler.

Quick Architecture Reference

Final Thoughts

The Portenta X8 is best understood as:

Its strongest architecture is to let each processor do what it is best at:

with the STM32 M7 acting as the bridge between the two worlds.

That division of labour is what makes Portenta X8 fundamentally different from a normal Linux SBC and from a normal Arduino board.

For the microcontroller-only Portenta alternative, see our Arduino Portenta H7 pinout guide. For the lower-cost Cortex-M33 member of the family, see our Arduino Portenta C33 pinout guide.