What Is MicroPython?

MicroPython is a compact implementation of the Python programming language designed to run directly on microcontrollers and small embedded systems. Unlike C or C++, which must be compiled into machine code before execution, MicroPython runs as an interpreter on the target hardware. This makes it especially well-suited for rapid development, experimentation, and educational use.

MicroPython is widely used on modern microcontroller platforms such as the Raspberry Pi Pico, ESP32, and some Arduino boards, and allows developers to write readable, high-level code while still interacting directly with hardware.

MicroPython follows standard Python syntax and semantics as closely as possible, with a few restrictions due to limited memory and processing power.

Key characteristics:
 

• indentation defines code blocks (no braces)
• dynamic typing (variables do not need explicit type declarations)
• automatic memory management (garbage collection)
• high-level data structures such as lists, tuples, and dictionaries

  Compared to the equivalent C/C++ code, this example is shorter and easier to read, at the cost of reduced execution speed.

Program Structure and Execution

MicroPython programs are typically executed in one of two ways:
 

1. Interactive execution: Based on the Read–Eval–Print Loop (REPL) paradigm where commands are typed directly into a prompt and executed immediately. This is useful for testing hardware and experimenting.
2. Script execution: Programs are stored as files on the microcontroller’s internal filesystem. A file named main.py is executed automatically when the board is powered up or reset.

Accessing Hardware

MicroPython provides hardware access through built-in modules, most notably the machine module. This module exposes microcontroller peripherals in a portable way.

Common features include:
 

• digital input and output (GPIO)
• analog-to-digital conversion (ADC)
• pulse-width modulation (PWM)
• timers
• communication interfaces (I²C, SPI, UART)

  Although MicroPython abstracts many hardware details, pin numbers and capabilities still depend on the specific board.

Performance and Memory Considerations

Because MicroPython is interpreted, it is inherently slower than compiled C/C++. This usually does not matter for:
 

• sensor reading
• user interfaces
• communication
• general control logic

However, MicroPython is less suitable for:
 

• very high-speed signal processing
• tight real-time control loops
• memory-intensive applications

Microcontrollers running MicroPython must reserve memory for the interpreter itself, leaving less RAM available for user programs than in a pure C/C++ environment.

Libraries and Ecosystem

MicroPython includes a small standard library and many hardware-specific modules. Additional drivers (for sensors, displays, etc.) are typically distributed as .py files that are copied directly to the device. There is no central package manager, making library (a.k.a. dependency) management therefore more manual, but also more transparent.
 

Error Handling and Debugging

One major advantage of MicroPython is its clear and informative error messages. Syntax errors and runtime exceptions are reported immediately, often with line numbers and descriptive messages. Combined with the interactive REPL, this makes debugging significantly easier than in many C/C++ workflows.

When to Use MicroPython

MicroPython is an excellent choice when:
 

• development speed is important
• code clarity and readability matter
• the application is not performance-critical
• learning and experimentation are primary goals

C or C++ is usually the better choice when:
 

• precise timing is required
• memory is extremely limited
• maximum execution speed is critical
• large, long-term projects demand tight control over resources

Data Types

MicroPython uses dynamic typing, which means that variables do not have a fixed type declared in advance. The type of a variable is determined automatically based on the value assigned to it.

Common data types include:
 

• int – integer numbers
• float – floating-point numbers
• bool – boolean values (True or False)
• str – strings (text)
• list – ordered collections
• tuple – immutable ordered collections
• dict – key–value pairs

 
There is no distinction between int, long, or float sizes at the language level; these details are handled internally by the interpreter.

Variables and Constants

Variables in MicroPython are created by assignment. There is no separate declaration step.
 
MicroPython does not enforce constants at the language level. By convention, variables written in uppercase are treated as constants and should not be modified.
 
This convention improves code readability but is not enforced by the interpreter.

Control Structures

MicroPython provides the same fundamental control structures as standard Python.

Conditional statements
 
Indentation is significant in MicroPython and replaces the braces {} used in C/C++.

Loops
A while loop:
 
A for loop:
 
There is no traditional for (init; condition; increment) loop as in C/C++; iteration is based on sequences and ranges.

Functions

Functions are defined using the def keyword. They may accept parameters and return values.
 
Functions do not require type declarations for parameters or return values. This makes functions easy to write but also shifts responsibility for correctness to the programmer.

Conclusion

MicroPython provides a modern, accessible way to program microcontrollers using a high-level language. While it cannot fully replace C or C++ in performance-critical applications, it greatly lowers the barrier to entry and accelerates development for a wide range of embedded projects. By understanding both approaches, developers can choose the right tool for each task and even combine them within the same project when appropriate.

---

Editor's Note: This article is an excerpt from the book, Programming Microcontrollers in MicroPython (C. Valens, Elektor 2026), which comes with the Elektor course, Raspberry Pi Pico with MicroPython (Programming Course). The book introduces embedded programming through MicroPython on popular platforms including the Raspberry Pi Pico and the ESP32. Readers discover how to use microcontrollers for reading inputs, processing data, and controlling outputs in a predictable, real-time loop. With some straightforward code, you can blink LEDs, read sensors, drive motors, and communicate with your environment. The interactive REPL programming interface encourages experimentation and fast learning.