TL;DR:

  • MicroPython is the more established runtime with broader hardware support and a stronger ecosystem for production IoT applications
  • CircuitPython is Adafruit’s beginner-friendly fork with a drag-and-drop programming model and excellent documentation for learning
  • For ESP32 production deployments, MicroPython is the standard choice; for RP2040 beginner hardware and education, CircuitPython has significant advantages

Python is the dominant language for data science, machine learning, and backend development. Its presence on microcontrollers is more recent but increasingly significant. Two implementations compete for the same space: MicroPython, the original port of Python 3 to microcontrollers, and CircuitPython, Adafruit’s fork of MicroPython tailored for their hardware and focused on accessibility.

Both run on many of the same chips. Both let you write Python 3 syntax to control hardware. But they’ve diverged meaningfully in their tooling, ecosystems, and intended use cases.

Origins and Philosophy

MicroPython was created by Damien George and launched in 2014 via a Kickstarter campaign. The goal was a full Python 3 implementation optimised for microcontrollers with kilobytes of RAM rather than gigabytes. It’s been ported to a wide range of hardware and is maintained as an open-source project with contributions from an international community. MicroPython prioritises Python compatibility and performance.

CircuitPython was forked from MicroPython by Adafruit in 2017. Adafruit’s goal was to create a version of MicroPython that was more accessible to beginners, particularly in educational contexts. The key early differentiator: CircuitPython boards appear as USB mass storage devices. You edit your code in a file called code.py, save it, and the board reloads automatically — no toolchain required, no driver installation, no serial monitor setup. Any text editor on any operating system works.

Hardware Support

MicroPython runs on:

  • ESP32 and ESP32-S2/S3 (Espressif) — the dominant IoT platform
  • ESP8266 (older but still widely deployed)
  • STM32 family (ST Microelectronics)
  • RP2040 (Raspberry Pi) — strong community support
  • nRF52840 (Nordic Semiconductor)
  • SAMD21/SAMD51 (Microchip)
  • Several others via community ports

CircuitPython runs on:

  • Adafruit’s own hardware (Circuit Playground, Feather series, Metro, etc.) — best-in-class support
  • RP2040 — the Pi Pico and Pico W have excellent CircuitPython support
  • SAMD21/SAMD51 — Adafruit’s historical focus area
  • ESP32-S2 and ESP32-S3 — added more recently
  • nRF52840
  • Notably: ESP32 (original) is not officially supported in CircuitPython as of 2026, despite being the dominant IoT chip

The ESP32 gap matters. If you’re building something with an ESP32 (which is the default choice for Wi-Fi enabled IoT nodes), CircuitPython isn’t an option for the classic ESP32 variant. MicroPython is.

Development Experience

MicroPython tooling:

  • mpremote is the official tool for file management, REPL access, and running scripts on connected boards
  • rshell and ampy are older alternatives still in common use
  • Thonny IDE has built-in MicroPython support and is popular for beginners
  • VS Code with the MicroPico or Pymakr extensions provides a more complete development experience
  • Uploading files requires a serial connection or Wi-Fi (on supported boards)

CircuitPython tooling:

  • The USB mass storage approach means CircuitPython boards just work with any editor
  • Mu Editor is the recommended beginner IDE — it detects CircuitPython boards automatically
  • CircuitPython 9.x added enhanced REPL features and improved USB serial output
  • The circup tool manages library installation and updates cleanly

For a beginner plugging in a Raspberry Pi Pico W and wanting to blink an LED within five minutes, CircuitPython with Mu Editor wins easily. For a developer setting up a fleet of ESP32 nodes for an industrial IoT deployment, MicroPython with VS Code and version-controlled code is more appropriate.

Library Ecosystems

MicroPython libraries are distributed informally — you find them on GitHub, copy the .py file to your board, and import it. The micropython-lib project provides a curated set of standard-ish libraries, but the ecosystem is fragmented. For common protocols (MQTT, HTTP, I2C sensors), libraries exist and work well. For newer or more obscure hardware, you may need to write your own or adapt C code.

Adafruit’s CircuitPython library bundle is the ecosystem’s strongest advantage. Adafruit publishes and maintains hundreds of drivers for their hardware breakout boards, and the quality is consistently high. Sensor libraries, display drivers, wireless modules — if Adafruit sells it, there’s a CircuitPython library for it. The circup tool installs and updates these libraries cleanly.

If you’re primarily using Adafruit breakout boards and sensors, CircuitPython’s library bundle is a genuine productivity advantage. If you’re integrating with arbitrary third-party hardware, MicroPython’s wider community and DIY library culture may serve you better.

Performance

MicroPython is generally faster than CircuitPython for CPU-intensive tasks. CircuitPython’s additional abstractions and the overhead of the USB-mass-storage file system add latency. For most IoT applications — reading sensor values, publishing to MQTT, controlling displays — this difference is imperceptible. For real-time control, signal processing, or applications where every millisecond counts, MicroPython is preferable.

Both are slower than C/C++ implementations on the same hardware by a significant margin (10–100x depending on the operation). For applications that genuinely need bare-metal performance, neither is the right choice.

When to Choose MicroPython

  • Production IoT deployments where remote management and code updates matter
  • ESP32-based designs (Wi-Fi, Bluetooth, low-power modes)
  • Applications requiring performance or precise timing
  • Teams with Python experience who want a mature, stable ecosystem
  • Projects that benefit from community forums with years of indexed troubleshooting

When to Choose CircuitPython

  • Education, workshops, and maker events where simplicity of setup matters
  • Adafruit hardware (you’re getting first-class support)
  • Raspberry Pi Pico W projects where RP2040’s CircuitPython support is excellent
  • Rapid prototyping where the USB drag-and-drop workflow is faster than managing a serial connection
  • Projects where you’ll use Adafruit’s sensor breakouts and want their library bundle

The two runtimes are not in direct competition for the same users. MicroPython is the production IoT runtime; CircuitPython is the learning and maker runtime. The right choice is mostly determined by your hardware (ESP32 means MicroPython), your audience (beginners means CircuitPython), and whether you’re prototyping or deploying.