MicroPython vs CircuitPython on Raspberry Pi Pico: Which to Learn?

When I first unpacked my Raspberry Pi Pico, I faced a decision that confuses many newcomers to the RP2040 ecosystem. Should I learn micropython pico programming or go with circuitpython pico instead? Both options promise Python-powered microcontroller development, but they’re not identical twins. After spending considerable time with both environments across dozens of projects, I can share practical insights that will help you make the right choice for your situation.

This guide breaks down the real differences between pico micropython and CircuitPython, covering installation, libraries, performance, and use cases. Whether you’re building your first LED blinker or designing production hardware, understanding these distinctions matters.

What Are MicroPython and CircuitPython?

Before diving into comparisons, let’s clarify what these implementations actually are and where they came from.

MicroPython: The Original

MicroPython is a lean implementation of Python 3 created by Damien George in 2013, specifically optimized for microcontrollers and constrained environments. It runs directly on the hardware without requiring an operating system, essentially becoming the operating system itself. The micropython pico port is officially maintained by Raspberry Pi, making it the “default” Python option for the Pico.

MicroPython aims to be as compatible with standard Python as possible while accounting for the limited resources of microcontrollers. It includes a small subset of the Python standard library plus hardware-specific modules like machine, rp2, and network for interacting with GPIO, PIO, and wireless features.

CircuitPython: The Beginner-Friendly Fork

CircuitPython emerged in 2017 when Adafruit forked MicroPython to create something more accessible for education and beginners. The circuitpython pico implementation emphasizes getting started quickly with minimal friction. While approximately 95% of the code you write will work identically in both environments, CircuitPython makes deliberate design choices that prioritize simplicity over flexibility.

Adafruit maintains CircuitPython alongside their extensive hardware ecosystem, which means excellent driver support for sensors, displays, and peripherals sold through their store. The tradeoff is that some advanced features available in MicroPython may be absent or implemented differently.

Core Differences Between MicroPython and CircuitPython

Understanding the fundamental architectural differences helps explain why each environment behaves the way it does.

Feature Comparison Table

Feature	MicroPython	CircuitPython
Official Pico Support	Yes (Raspberry Pi)	Yes (Adafruit)
USB Drive Mode	No (requires tools)	Yes (CIRCUITPY drive)
Auto-Reload on Save	No	Yes
Dual-Core Support	Yes (experimental)	Limited
USB HID Built-in	No	Yes
PIO Support	Complete API	Partial API
Library Ecosystem	Community-driven	Curated by Adafruit
Main Code File	main.py	code.py
Interrupt Support	Full	Limited
Threading	Supported	Not supported
Memory Efficiency	Higher	Lower
Beginner Friendliness	Moderate	High

File Management Philosophy

The most immediately noticeable difference involves how you transfer code to your Pico.

When you flash circuitpython pico firmware, the board appears as a USB mass storage device called “CIRCUITPY”. You simply drag and drop Python files onto this drive. Save a file named code.py, and CircuitPython automatically detects the change and restarts your program. This workflow feels natural to anyone who has used a USB flash drive.

Pico micropython takes a different approach. The board connects as a serial device, and you interact with it through tools like Thonny IDE or command-line utilities like rshell and mpremote. While Thonny simplifies this considerably with its built-in file browser, the experience differs from the plug-and-play simplicity of CircuitPython’s USB drive.

API Consistency

CircuitPython enforces a unified hardware API across all supported boards. Whether you’re using a Pico, an ESP32-S3, or a SAMD51-based Feather, the code for controlling GPIO, I2C, SPI, and other peripherals remains identical (pin names may vary, but function calls don’t).

MicroPython’s APIs can differ between ports. Code written for an ESP32 may need modifications to run on the Pico, particularly when dealing with hardware-specific features. This flexibility allows tighter optimization for each platform but requires more attention when porting projects.

Installing MicroPython on Raspberry Pi Pico

Getting micropython pico running takes just a few minutes:

1. Download the latest MicroPython UF2 file from micropython.org/download/RPI_PICO/
2. Hold the BOOTSEL button while connecting your Pico via USB
3. The Pico appears as a drive called “RPI-RP2”
4. Drag the UF2 file onto this drive
5. The Pico reboots automatically with MicroPython installed

For Pico W boards with WiFi, download the specific Pico W firmware instead of the standard version.

Basic MicroPython LED Blink

from machine import Pin

import time

led = Pin(25, Pin.OUT)

while True:

    led.toggle()

    time.sleep(0.5)

This example uses the machine module, MicroPython’s interface for hardware control. Pin 25 connects to the onboard LED on standard Pico boards.

Installing CircuitPython on Raspberry Pi Pico

The circuitpython pico installation process is nearly identical:

1. Download the UF2 from circuitpython.org/board/raspberry_pi_pico/
2. Hold BOOTSEL while connecting via USB
3. Drag the UF2 file onto the RPI-RP2 drive
4. After reboot, a new CIRCUITPY drive appears

Basic CircuitPython LED Blink

import board

import digitalio

import time

led = digitalio.DigitalInOut(board.LED)

led.direction = digitalio.Direction.OUTPUT

while True:

    led.value = not led.value

    time.sleep(0.5)

Notice the different module structure. CircuitPython uses board for pin definitions and digitalio for GPIO control. The board.LED constant automatically maps to the correct onboard LED regardless of which supported board you’re using.

Library Ecosystems Compared

Library availability often determines which environment works best for a specific project.

CircuitPython Library Advantages

Adafruit maintains over 300 libraries covering sensors, displays, communication protocols, and more. These libraries install by copying files to the CIRCUITPY drive’s lib folder. The curated nature means libraries work together without conflicts and receive consistent updates.

Library Category	CircuitPython Coverage
Temperature/Humidity Sensors	50+ drivers
OLED/LCD Displays	30+ drivers
Motor Controllers	20+ drivers
Environmental Sensors	40+ drivers
Communication Modules	25+ drivers
LED Controllers	15+ drivers

If you’re using Adafruit hardware or common breakout boards, CircuitPython almost certainly has a working driver ready to go.

MicroPython Library Situation

MicroPython’s library ecosystem is more fragmented. While many excellent libraries exist, they’re scattered across GitHub repositories, forums, and personal websites. A driver that works on one MicroPython board may require modification for the Pico. The community-driven nature means quality varies significantly.

That said, MicroPython provides lower-level access that allows writing custom drivers when needed. If you’re comfortable reading datasheets and implementing protocols, the flexibility can be liberating rather than limiting.

Blinka: Bridging the Gap

Adafruit’s Blinka compatibility layer lets you use CircuitPython libraries within MicroPython. Installation requires copying several files to your Pico, and not every library works perfectly, but it can be a viable option when you need a specific CircuitPython driver while using pico micropython.

Performance and Resource Usage

When working with microcontrollers, efficiency matters. Both implementations compile Python to bytecode that runs on a virtual machine, but they make different tradeoffs.

Memory Comparison

Metric	MicroPython	CircuitPython
Base RAM Usage	~50KB	~70KB
Available for User Code	~200KB	~180KB
Flash Usage (Firmware)	~700KB	~900KB
Typical Free Flash	~1.3MB	~1.1MB

MicroPython’s smaller footprint leaves more resources for your application. For projects involving large data buffers, image processing, or complex state machines, this headroom can prove critical.

Dual-Core Processing

The RP2040 contains two Cortex-M0+ cores, and micropython pico provides experimental support for utilizing both. You can spawn functions on the second core using the _thread module. While documentation warns about stability issues, many developers use dual-core MicroPython successfully in production.

CircuitPython currently lacks equivalent dual-core support. Adafruit has prioritized other features, so CPU-intensive applications requiring parallel processing favor MicroPython.

PIO (Programmable I/O) Access

Both environments support the RP2040’s unique PIO state machines, but MicroPython provides a more complete API. CircuitPython’s rp2pio module handles common use cases like NeoPixel timing, but complex custom PIO programs may require MicroPython’s fuller implementation.

When to Choose MicroPython

Pico micropython makes sense for several scenarios:

Advanced Hardware Control: If your project requires interrupts, threading, or complete PIO access, MicroPython provides the necessary low-level control.

Memory-Constrained Applications: Projects pushing the RP2040’s RAM limits benefit from MicroPython’s smaller footprint.

Official Raspberry Pi Ecosystem: Following Raspberry Pi’s own tutorials and documentation is easier with their officially supported MicroPython port.

Porting from Other Platforms: Existing MicroPython code from ESP32 or STM32 projects often transfers to the Pico with minimal changes.

Production Deployments: The larger community means more eyes on the codebase and faster bug fixes for stability-critical applications.

When to Choose CircuitPython

CircuitPython pico excels in different situations:

Rapid Prototyping: The USB drive workflow and auto-reload feature accelerate the edit-test cycle dramatically.

Beginner Projects: Students and hobbyists benefit from CircuitPython’s gentler learning curve and better error messages.

Adafruit Hardware Integration: Using Adafruit sensors and displays? CircuitPython’s driver library saves hours of development time.

USB HID Devices: Building a custom keyboard, mouse, or game controller is straightforward with CircuitPython’s built-in USB HID support.

Cross-Platform Projects: Code that needs to run on multiple board types benefits from CircuitPython’s consistent APIs.

MIDI Controllers: CircuitPython’s MIDI libraries are more mature and easier to use than MicroPython equivalents.

Switching Between Environments

Here’s encouraging news: you’re not locked into your choice permanently. Switching between MicroPython and CircuitPython takes about two minutes. Hold BOOTSEL, connect USB, drag a different UF2 file, and you’re running the other environment. Your old code files are erased during this process, so back up anything important first.

Many developers maintain both environments for different projects. Use CircuitPython when library availability matters, switch to MicroPython when you need dual-core processing or complete PIO control.

Development Environment Comparison

Tool	MicroPython Support	CircuitPython Support
Thonny IDE	Excellent	Good
Mu Editor	Good	Excellent
VS Code	Via extensions	Via extensions
PyCharm	Limited	Limited
Command Line	rshell, mpremote	Direct file copy
Web-Based	None	code.circuitpython.org

Thonny remains the recommended IDE for both environments, particularly for beginners. It handles serial connections, file transfers, and REPL interaction seamlessly.

Useful Resources and Downloads

MicroPython Resources

• Official MicroPython Firmware: micropython.org/download/RPI_PICO/
• MicroPython Documentation: docs.micropython.org/en/latest/rp2/
• Raspberry Pi Pico Python SDK: datasheets.raspberrypi.com/pico/raspberry-pi-pico-python-sdk.pdf
• MicroPython Libraries: github.com/micropython/micropython-lib
• Awesome MicroPython: github.com/mcauser/awesome-micropython

CircuitPython Resources

• CircuitPython Firmware: circuitpython.org/board/raspberry_pi_pico/
• CircuitPython Documentation: docs.circuitpython.org
• Library Bundle: circuitpython.org/libraries
• Adafruit Learning System: learn.adafruit.com/category/circuitpython
• CircuitPython Discord: adafru.it/discord

Development Tools

• Thonny IDE: thonny.org
• Mu Editor: codewith.mu
• mpremote Tool: docs.micropython.org/en/latest/reference/mpremote.html

Frequently Asked Questions

Can I run MicroPython and CircuitPython simultaneously on the same Pico?

No, you cannot run both environments simultaneously. Each installs as complete firmware that takes over the entire flash memory. You must choose one at a time, though switching between them only requires flashing a different UF2 file. Some users keep multiple Picos dedicated to different environments for convenience.

Is CircuitPython slower than MicroPython?

Performance differences exist but are typically negligible for most projects. CircuitPython’s additional abstraction layers create slight overhead, and its larger memory footprint leaves less RAM for user code. For timing-critical applications like high-frequency data acquisition, MicroPython’s leaner implementation may provide measurable advantages. For typical sensor reading and display projects, you won’t notice any difference.

Which has better WiFi support for the Pico W?

Both environments support the Pico W’s wireless capabilities, though implementation details differ. MicroPython uses the network module following patterns familiar from ESP32 development. CircuitPython provides wifi and socketpool modules with its characteristic simplified API. Neither is definitively “better”; choose based on your overall environment preference rather than WiFi features alone.

Can I use CircuitPython libraries in MicroPython?

Partially, yes. Adafruit’s Blinka compatibility layer allows many CircuitPython libraries to run under MicroPython. Installation requires copying Blinka and PlatformDetect files to your Pico, then adding desired libraries. Not everything works perfectly due to underlying API differences, but common sensor and display drivers often function correctly with minor adjustments.

Which should an absolute beginner choose?

For complete beginners, CircuitPython offers the gentler introduction. The USB drive workflow eliminates the need to learn additional tools, auto-reload provides instant feedback, and error messages are more descriptive. However, if you’re following Raspberry Pi’s official documentation or taking a course that specifies MicroPython, stick with that to avoid confusion. Both environments teach Python fundamentals that transfer between them.

Making Your Decision

After evaluating both environments extensively, here’s my practical recommendation: start with whichever matches your immediate project needs. If you’re using Adafruit hardware or need USB HID functionality, CircuitPython’s library ecosystem provides significant value. If you’re following Raspberry Pi tutorials, need dual-core support, or prefer official platform backing, MicroPython makes more sense.

The good news is that skills transfer between environments. Learning micropython pico development teaches concepts that apply equally to circuitpython pico, and vice versa. The underlying Python syntax is identical; only the hardware libraries differ. Consider learning both eventually, choosing the appropriate tool for each project rather than declaring permanent allegiance to one camp.

The Pico’s inexpensive price point makes owning multiple boards practical. Keep one running MicroPython for projects requiring its advanced features, another running CircuitPython for rapid prototyping with Adafruit sensors. This flexibility represents one of the RP2040 platform’s greatest strengths.

Whatever you choose, you’re joining a vibrant community of makers, educators, and engineers using Python to bring hardware projects to life. Welcome to the world of embedded Python development.