MicroPython with Arduino Boards: Complete Practical Guide

Home » Python » MicroPython with Arduino Boards: Complete Practical Guide

If you already feel comfortable with “regular” Python and you’ve just stumbled upon MicroPython, you’re not alone. Many developers make exactly the same discovery when they start tinkering with microcontrollers like Arduino, ESP32 or Raspberry Pi Pico. At first glance, the syntax looks almost identical to CPython, but suddenly there are new modules, hardware-specific classes and a different way of flashing and running code on boards.

This guide pulls together the key information from the best‑ranking English resources about MicroPython and Arduino and mixes it with practical, real‑world context. You’ll see where the official MicroPython code lives, which Arduino‑compatible boards can actually run MicroPython, what kind of drivers and libraries are available, and how to get started if you have an Arduino‑style board such as an ESP‑based NodeMCU, a Nano ESP32, a Nano RP2040 Connect or a Portenta.

What MicroPython is and how it relates to Arduino

MicroPython is a lean implementation of the Python language designed to run directly on microcontrollers. Instead of running on a full desktop OS, MicroPython executes on tiny chips with limited RAM and flash memory, giving you a Python prompt right on the device. The language core stays very close to CPython, so your existing Python knowledge largely carries over, but you get extra modules such as machine, network or uos to talk to pins, sensors, buses and storage.

The relationship with Arduino is mostly about hardware and APIs, not about the traditional Arduino “C++ sketches” environment. MicroPython targets specific boards and chips (ports) like ESP32, ESP8266, RP2040, nRF51/nRF52, STM32, SAMD, Renesas RA, and so on. Many modern Arduino‑branded boards are built on exactly those MCUs, which is what makes them compatible with MicroPython.

The classic Arduino Uno, based on the ATmega328P 8‑bit AVR, does not have an official MicroPython port. It’s simply too constrained in terms of flash and RAM, and the MicroPython VM is not designed for such a small chip. That’s why you’ll see community questions like “How do I run MicroPython on Arduino Uno?” and the short, honest answer is: you typically can’t, and if you somehow do, it will be extremely limited and not officially supported.

Where Arduino and MicroPython really meet is on newer “Arduino” boards that use 32‑bit MCUs with enough resources. Boards such as Arduino Nano ESP32, Arduino Nano RP2040 Connect, Arduino Nano 33 BLE Sense, Arduino Giga, Portenta H7, Portenta C33, Nicla Vision, Nicla Sense Env and Opta WiFi sit on top of chips like ESP32, RP2040, STM32H7, Renesas RA6M5, and similar families. Those MCUs do have official or actively developed MicroPython ports.

Official MicroPython source, builds and supported ports

MicroPython is developed in the open using Git for version control, and the canonical repository lives on GitHub at github.com/micropython/micropython. That repository holds the full interpreter source, the core libraries and the ports for various microcontroller families. If you ever need to inspect the internals or build your own firmware image, that’s the place to go.

The project provides a full source‑code distribution of the latest stable version as downloadable archives. These releases bundle the interpreter, libraries and ports in a snapshot that you can compile yourself. For people who want to live even closer to the edge, there are daily snapshots of the GitHub repository available from the MicroPython server. Those snapshots usually omit Git submodules but track the current state of development, which is useful if you’re testing new features or submitting patches.

On top of the source code, MicroPython offers automatically built firmware images for a wide range of boards and architectures. These firmwares are generated daily for different ports, including:

• alif
• cc3200
• esp32 (with variants like esp32c2, esp32c3, esp32c5, esp32c6, esp32p4, esp32s2, esp32s3)
• esp8266
• mimxrt (i.MX RT)
• nrf (nRF51, nRF52, nRF91)
• renesas‑ra (RA4M1, RA4W1, RA6M1, RA6M2, RA6M5, etc.)
• rp2 (RP2040, RP2350)
• samd (SAMD21, SAMD51)
• stm32 (STM32F0, F4, F411, F7, G0, G4, H5, H7, L0, L1, L4, U5, WB, WL)

Those daily builds are usually grouped and filterable by features, vendor and MCU so you can quickly find a firmware image that matches your board. Feature filters include capabilities such as Audio Codec, BLE, Battery Charging, CAN, Camera, DAC, Display, Dual‑core, Environment Sensor, Ethernet, External Flash, External RAM, Feather, IMU, JST‑PH/JST‑SH, LoRa, Microphone, PoE, RGB LED, SDCard, Secure Element, USB/USB‑C, WiFi, microSD, and mikroBUS. There’s also a vendor filter where you can, for instance, narrow results down to Arduino‑branded boards.

Several Arduino boards are explicitly listed or implicitly covered via their MCUs. Among the Arduino names connected with MicroPython builds you’ll find:

• Giga
• Arduino Nano 33 BLE Sense
• Arduino Nano ESP32
• Arduino Nano RP2040 Connect
• Arduino Nicla Vision
• Arduino Nicla Sense Env (served via a specific library)
• Arduino Opta WiFi
• Arduino Portenta C33
• Arduino Portenta H7 (often referenced as envie_m7 variant)

Because firmware images are built per port and board, your first step is always to identify the exact MCU and variant used by your Arduino board. For example, an Arduino Nano ESP32 maps to the esp32 port, while a Nano RP2040 Connect uses the rp2 port. A Portenta H7 falls under the stm32 high‑end family, and a Portenta C33 leans on the renesas‑ra port. Matching these up ensures you flash the correct MicroPython binary.

Does MicroPython work on all Arduino boards?

This is one of the most common questions from people who discover MicroPython after working with the Arduino ecosystem. The short version is: MicroPython does not support every Arduino board, but it does support many newer ones that use 32‑bit MCUs with enough memory and flash.

The boards where MicroPython is not realistically an option are the old‑school AVR Arduinos like the Uno, Nano (classic), Mega or Leonardo. Those boards rely on 8‑bit AVR microcontrollers with limited resources. While there have been experimental ports and ultra‑minimal forks in the community, the official MicroPython project focuses on more capable 32‑bit architectures, so you shouldn’t expect a polished, officially maintained MicroPython firmware for the Uno.

By contrast, NodeMCU and similar ESP8266/ESP32 development boards are a great match for MicroPython and are actively supported. NodeMCU typically uses an ESP8266 or ESP32 chip, both of which have stable and popular MicroPython ports. Flashing MicroPython to a NodeMCU gives you a very friendly way to do WiFi‑enabled IoT development with Python syntax instead of the Arduino C++ dialect.

For Arduino‑branded hardware, focus on models that reuse the same MCUs as mainstream MicroPython boards. This includes a broad family:

• Arduino Nano ESP32 — ESP32‑based; uses the esp32 port.
• Arduino Nano RP2040 Connect — based on the Raspberry Pi RP2040; uses the rp2 port.
• Arduino Nano 33 BLE Sense — Nordic nRF52; supported through the nrf port.
• Arduino Giga — high‑end STM32H7 MCU; covered via stm32 port.
• Arduino Portenta H7 — STM32H7 dual‑core; supported through stm32.
• Arduino Portenta C33 — Renesas RA microcontroller; tied to the renesas‑ra port.
• Arduino Nicla Vision and related Nicla boards — built around supported MCUs and addressed with specialized MicroPython drivers.
• Arduino Opta WiFi — industrial‑oriented, but built on supported STM32 parts.

If you’re holding an Arduino Uno and a NodeMCU side by side, only the NodeMCU is really a first‑class candidate for MicroPython. With the Uno, it’s more pragmatic to either stay with Arduino C++ or upgrade to a modern, MicroPython‑friendly board that still fits well into the Arduino ecosystem, like the Nano ESP32 or Nano RP2040 Connect.

Do you need a new IDE or extra tools for MicroPython?

MicroPython development feels different from compiling Arduino sketches, but you don’t necessarily need a heavyweight new IDE. Because MicroPython runs an interpreter on the board, you usually work with plaintext .py files and a serial REPL instead of compiled .hex or .bin sketches.

The essential requirements are a way to flash firmware to the board and a tool to upload Python files and talk to the REPL. For flashing, you typically rely on vendor tools or command‑line utilities like esptool.py (for ESP8266/ESP32), or you use the board’s bootloader support (UF2 for RP2040, DFU for STM32, etc.). Many MicroPython web pages and docs give you concrete flashing instructions per port.

For editing and file transfer, you can keep using your favorite code editor and just add a MicroPython‑aware helper. Common options include:

• Thonny — a simple Python IDE with built‑in MicroPython support, serial REPL and file management.
• Mu Editor — beginner‑friendly editor that speaks MicroPython and CircuitPython.
• VS Code with extensions — you can use regular Python support together with add‑ons that handle MicroPython upload/REPL.
• ampy / rshell / mpremote — command‑line tools to upload scripts, list files and interact with the REPL on the device.

On some Arduino‑branded boards, you’ll also find integration paths that let you stay close to the Arduino world while still writing MicroPython code. Certain tools and libraries allow you to structure your MicroPython programs with an Arduino‑style setup() and loop(), and expose familiar functions like digitalWrite or analogRead behind the scenes. This lets long‑time Arduino users feel more at home, even though the underlying runtime is MicroPython.

In practice, switching to MicroPython usually means you stop using the classic Arduino IDE for those projects and move to a Python‑oriented workflow. That said, your mental model of “board + pins + libraries + examples” stays intact, and after a day or two of tinkering, the MicroPython editor + REPL combo feels very natural.

Getting started: from Arduino Uno and NodeMCU to MicroPython

If your goal is to run MicroPython on an Arduino Uno, you’re likely to hit a hard wall. The interpreter is simply too big for the Uno’s ATmega328P, and the official project doesn’t provide a maintained port. You might find experimental forks or highly stripped‑down derivatives, but they won’t behave like a normal MicroPython environment, and many libraries won’t fit. For most people, the pragmatic move is to accept that the Uno is a “classic Arduino C++” board and choose a different device for MicroPython experiments.

With a NodeMCU (ESP8266 or ESP32 variant), however, you can follow a straightforward route to MicroPython. The exact steps differ slightly by chip, but the general flow is:

• 1. Download the appropriate MicroPython firmware for your esp8266 or esp32 port from the MicroPython downloads page or the daily builds server. Make sure the build matches your flash size and board family.
• 2. Erase and flash the board using esptool.py (or equivalent) from your computer. This wipes the existing firmware (often NodeMCU Lua or Arduino sketches) and installs MicroPython instead.
• 3. Connect a serial terminal or REPL tool (like Thonny, Mu, mpremote or a generic serial console) at the right baud rate. You should see the familiar >>> Python prompt if everything went well.
• 4. Create and upload scripts named boot.py and main.py, or any other modules you want to import. These will run automatically or be available for interactive import.

The same pattern applies to many Arduino‑branded boards that are MicroPython‑friendly, with the only real difference being the exact flashing tooling and bootloader behavior. For example, an RP2040‑based Arduino will use the UF2 bootloader (drag‑and‑drop a .uf2 file), while a Portenta H7 will rely on STM32 boot mechanisms or manufacturer utilities. Once flashed, the Python side looks very similar: machine.Pin for GPIO, machine.I2C for sensors, and so on.

An extra convenience available in the Arduino ecosystem is a MicroPython helper library that lets you write code in a sketch‑like style. This library provides Arduino‑ish APIs and even a MicroPython implementation of setup() and loop(). You can, for instance, write something conceptually similar to an Arduino sketch, but under the hood it’s running on a MicroPython runtime with Python syntax and semantics. That makes transition smoother for people who have years of Arduino habits.

MicroPython packages and libraries for Arduino‑compatible boards

One of the strongest points of MicroPython on Arduino‑class boards is the growing ecosystem of hardware drivers and helper libraries. The MicroPython community maintains a MicroPython Package Index that lists reusable modules which can be installed or copied onto supported boards, including many with explicit verification on Arduino products.

The contribution guidelines for this index describe how to submit new packages, document them properly and tag them with relevant features. This ensures that when you search for a sensor or display, you can quickly find a driver that’s known to work with specific microcontroller ports or even particular Arduino boards.

Among the available libraries, some are dedicated specifically to Arduino hardware, while others are generic drivers that just happen to run beautifully on Arduino‑branded boards. For instance, there’s a MicroPython library to control Arduino Modulinos, which are modular add‑ons that integrate tightly with Arduino hardware. Another notable package is a MicroPython library for the Arduino Nicla Sense Env, focused on environmental sensing capabilities of that board.

There’s also a standout helper that makes it easy to write code using Arduino‑style patterns like setup/loop and familiar APIs while staying in MicroPython. This package effectively bridges the conceptual gap between “Arduino sketches” and Python modules, letting users keep muscle memory like calling digitalWrite while actually leveraging MicroPython’s runtime and REPL.

Besides those Arduino‑flavored libraries, the ecosystem contains a long list of sensor, display, storage and utility drivers that support MicroPython on common MCUs and boards. Many of these have been tested on boards such as arduino:esp32:nano_nora, various esp32s3 devices, and high‑end mbed_portenta variants. The verification notes often specify the MicroPython version and board ID used, so you know the library isn’t theoretical.

Notable MicroPython drivers and utilities you can use

The MicroPython Package Index hosts a rich collection of drivers covering environmental sensors, display controllers, IO expanders, storage, communication protocols and more. If you’re building projects on compatible Arduino boards, the odds are high that a ready‑to‑use driver exists for the hardware you want.

Environmental and gas sensors are well represented. You’ll find a MicroPython driver for the BME280 sensor (often referenced with Pycom devices as a target) and another for the BME680 breakout, communicating over I²C. These drivers handle temperature, humidity, pressure and gas readings, letting you hook up a board like Nano ESP32 or Nano RP2040 Connect to environmental sensors with just a few lines of Python.

Display control is equally well covered. There are Python drivers for the Holtek HT16K33 controller, which powers devices like the Adafruit 0.8‑inch 8×16 LED Matrix FeatherWing or certain Raspberry Pi Pico displays. These drivers support both CircuitPython and MicroPython via I²C, making them versatile and reusable across ecosystems. You also get MicroPython drivers for display controllers such as SH1106 and SH1107, used in various OLED panels, as well as packages for HD44780‑based character LCDs (1602 and 2004 models) driven over I²C.

For analog‑to‑digital conversion and IO expansion, several robust packages are available. There is a MicroPython driver for the ADS1x15 series of ADCs, widely used to add higher‑resolution analog inputs. Another library supports the MCP23017 16‑bit I/O Expander with I2C interface, which lets you dramatically increase the number of digital pins your Arduino‑class board exposes, all controlled from MicroPython.

A variety of LED driver packages cover visual feedback and displays. You’ll find a MicroPython library for the MAX7219 8×8 LED matrix driver using SPI and frame buffer, as well as a driver for quad 7‑segment LED displays based on the TM1637 chip. There is also a library for 10‑segment LED bar graphs using the MY9221 driver, and separate MicroPython modules for addressable LEDs such as WS2812B and SK6812 (often known generically as neopixels) on the Raspberry Pi Pico. These all pair nicely with Arduino‑branded boards that share the same MCU families.

Real‑time clocks and data logging use cases are supported through dedicated modules. One driver targets the DS3231 RTC combined with AT24C32 EEPROM, making it easy to keep accurate time and store configuration or small logs across power cycles. Combined with SDCard and microSD features available in specific ports, you can put together serious data‑logging setups using nothing but MicroPython scripts.

Non‑contact temperature sensing and capacitive input are also straightforward thanks to focused drivers. There’s a MicroPython library for the Melexis MLX90614 IR temperature sensor, enabling remote temperature measurement, and another for the MPR121 capacitive touch keypad and breakout boards, useful for touch‑based user interfaces. Both integrate smoothly over I²C and can be used with Arduino‑compatible MicroPython boards.

For biometric and audio‑related hardware, you’ll find specialized MicroPython ports. A package exists for the MAX30102 sensor, a popular pulse oximeter/heart‑rate module originally supported by SparkFun’s driver, now adapted to MicroPython. Audio playback modules are covered by a MicroPython implementation of DFPlayer control over UART, making MP3 playback accessible without heavy code.

Timing, motion and input devices get their own robust implementations. A MicroPython driver for rotary encoders uses GPIO interrupts and debouncing to give accurate, non‑jittery readings on boards like Pyboard, Raspberry Pi Pico, ESP8266 and ESP32. Servo control on the Raspberry Pi Pico is addressed through drivers that use PDM (Pulse Density Modulation) or simpler PWM‑based wrappers, and there are small helper classes focused on controlling 9g servos from MicroPython.

Infrared communication is handled by a pair of nonblocking drivers for receivers and blasters. One library focuses on receiving IR remote control codes, while another handles IR transmission for “blaster” applications. Both are designed for nonblocking operation so they can run comfortably alongside other MicroPython tasks.

For thermal printing and display output, a MicroPython port of Adafruit’s Python Thermal Printer library is available. This package lets you drive thermal receipt printers from boards like ESP32 or RP2040, again using MicroPython as the controlling environment.

Beyond hardware drivers, there are utilities that make Arduino‑powered IoT projects much simpler. One standout is a Python client for the Arduino IoT Cloud that works in both CPython and MicroPython. This package, hosted on GitHub under the Arduino organization and licensed under the Mozilla Public License 2.0, allows MicroPython devices to connect to the Arduino IoT Cloud for telemetry, dashboards and remote control. It has been verified on the arduino:mbed_portenta:envie_m7 platform running MicroPython, showing that high‑end Arduino boards can seamlessly integrate into Arduino’s cloud services from a Python runtime.

Some display and input libraries are designed initially around the Pycom flavor of MicroPython but still apply nicely to many Arduino‑class boards. For example, there’s an I2C LCD character‑screen interface package tailored to Pycom, and a MicroPython port of the ucPack library, both of which can often be re‑used or adapted for other MicroPython ports when the underlying bus and pin configuration matches.

Why MicroPython on Arduino‑class hardware is worth exploring

When you combine MicroPython’s dynamic, high‑level feel with the huge variety of Arduino‑compatible hardware, you get a very flexible prototyping platform. Instead of constantly recompiling sketches, you can iterate interactively: open the REPL, poke pins, read sensors, tweak logic and see instant feedback. That alone can sharply reduce development time for hobby projects, quick demos or even professional prototypes.

The ecosystem of MicroPython packages, with explicit support and verification on Arduino boards, means you rarely have to start from scratch with raw registers or complex C drivers. Libraries for sensors like BME280/BME680, displays powered by HT16K33, SH1106 or HD44780, IO expanders like MCP23017, and infrastructure pieces like ModBus TCP/RTU clients and hosts all help you stand on the shoulders of the community.

At the same time, the Arduino universe contributes cloud integrations and well‑engineered board designs. The dedicated Arduino IoT Cloud Python client is a good example of how the two ecosystems intersect: you can write MicroPython code on a Portenta‑class board, yet still leverage Arduino’s dashboards and IoT tooling. High‑end boards like the Giga or Portenta H7 bring dual‑core MCUs, Ethernet, WiFi, BLE, USB‑C and more under one roof, all of which can be exercised from MicroPython firmware.

There are, of course, trade‑offs. Some low‑level timing‑critical applications might still be better written in C/C++ as classic Arduino sketches, and very resource‑constrained boards like the original Uno are simply not suited to MicroPython. But for a large category of projects involving sensors, displays, connectivity and moderate real‑time demands, MicroPython on compatible Arduino hardware is a fast, approachable and surprisingly powerful combination.

For anyone coming from standard Python, moving into MicroPython on modern Arduino‑class boards like ESP32‑based Nanos, RP2040 Connect, or Portenta devices offers a smooth entry into embedded development while reusing your language skills, tapping into a rich package index, and taking advantage of the robust, well‑documented hardware that made Arduino so popular in the first place.