Pimoroni Pico Libraries for RP2040 and RP2350 Hardware

Pimoroni Pico's Hardware Support Boundary

Pimoroni Pico addresses a specific hardware problem: software support for boards and add-ons built around the Raspberry Pi Pico family. The repository covers both RP2040 and RP2350 products and supplies libraries, examples, and firmware assets for displays, sensor breakouts, packs, bases, and SHIMs. Its intended users include Raspberry Pi Pico beginners choosing the supplied MicroPython firmware and more experienced C/C++ developers building firmware with the Pico SDK.

The supported catalogue is broad, but it is not an unrestricted compatibility list. It names products such as Pico Display Pack, Pico Scroll Pack, Pico Audio Pack, Pico Enviro+ Pack, Pico Inky Pack, and several lighting and input products. It also lists Raspberry Pi Pico, Pico W, Pico 2, Pico 2 W, Pimoroni board variants, and Breakout Garden sensors including AS7262, MSA301, MICS6814, BH1745, BME280, BME688, BMP280, PMW3901, and others.

That boundary matters when selecting this repository for a new design. A sensor appearing in the example tree indicates that Pimoroni provides a relevant example, but the visible documentation does not promise compatibility with arbitrary I2C, SPI, or GPIO accessories. Projects using generic Raspberry Pi Pico libraries may be better served by an upstream driver or a hardware abstraction outside this repository. Projects using one of the explicitly supported Pimoroni products gain the most direct benefit because firmware builds and examples can target that hardware.

MicroPython Firmware and C/C++ Library Paths

The repository provides two distinct software paths. The MicroPython path supplies a custom firmware build with built-in drivers for Pimoroni displays, breakouts, and other hardware. This path removes the need for each user to assemble a firmware image from individual drivers, at least when the selected hardware is covered. The repository also keeps board-specific examples under `micropython/examples`.

The C/C++ path is lower-level. It contains reusable libraries under `libraries/` and `drivers/`, hardware examples under `examples/`, shared code under `common/`, and CMake integration through `CMakeLists.txt`, `pimoroni_pico_import.cmake`, and `pico_sdk_import.cmake`. For a new C++ project, the README directs developers to the separate `pimoroni/pico-boilerplate` repository. That boilerplate provides a project skeleton and GitHub workflows configured for testing, making this repository more of a library and example source than a complete application template.

The repository layout indicates that both paths share product-specific drivers while exposing different entry points to developers. MicroPython users work through a supplied firmware image and Python examples. C/C++ users compile against SDK libraries with CMake. This is a meaningful difference in deployment and debugging expectations. Python code can be changed in a MicroPython environment, while compiled applications require the Pico SDK toolchain and a build workflow.

Installing MicroPython for a Supported Pimoroni Board

Start with the release page rather than treating the repository as a Python package to install with a package manager. The README links to the latest release for Pimoroni's prebuilt MicroPython build and separately points users to `setting-up-micropython.md`. That file is the authoritative installation path for flashing firmware onto a board, so the exact device-selection and copy steps should be taken from it rather than reconstructed from assumptions.

A new user's first real use can begin after flashing: connect the hardware, open a MicroPython prompt, select an example for the exact product under `micropython/examples`, and adapt it to the attached sensor or display. Examples are organized by product, including breakout directories under `examples/breakout_as7262`, `examples/breakout_bme280`, `examples/breakout_msa301`, and `examples/breakout_mlx90640`. The MicroPython tree is the appropriate place to look for Python versions of supported hardware demonstrations.

It also does not document a rollback procedure for firmware flashing. Before overwriting a working device, users need to consult `setting-up-micropython.md` and preserve any local `main.py` or other files required by their own application. The custom build includes inherited changes from upstream MicroPython, but the repository is still tied to specific firmware images rather than acting as a general MicroPython distribution.

Building a C++ Example with the Pico SDK

The C/C++ workflow starts with the SDK setup instructions in `setting-up-the-pico-sdk.md`. The repository includes its own CMake files and a separate `pico-boilerplate` reference, but the README does not give a single universal build command that applies to every example or board. A developer should therefore complete the documented SDK setup and use the build procedure belonging to the selected example or boilerplate project.

For a first compiled project, select an example matching the attached hardware from `examples/`. Each named directory represents a concrete target rather than a generic template. The layout includes support for automation hardware, display breakouts, environmental sensors, gas sensors, motion sensors, rotary encoders, matrix inputs, OLED displays, and particulate sensors. This makes it possible to compare the library imports and pin assumptions in a relevant example before writing new application code.

The C/C++ path also has a higher setup cost than installing a MicroPython firmware image. The README links to platform-specific guidance for Pico C++ development on Windows using WSL, while the repository itself is organized around the Pico SDK. Users who need full native control can use it, but they must account for toolchain setup, board definitions, build configuration, and hardware-specific examples. The documented examples and library directories provide a reference, not a guarantee that a new board configuration can be selected without additional work.

RP2040 and RP2350 Compatibility Boundaries

Coverage of both RP2040 and RP2350 is a defining feature. The README states that its MicroPython builds now target both chip families, and the supported board list includes Raspberry Pi Pico and Pico W alongside Pico 2, Pico 2 W, Tiny 2040, Tiny 2350, PGA2040, and PGA2350. The latest listed release is explicitly described as containing working Pico 2 builds.

That statement should still be read narrowly. Chip-family support does not mean that every product supported on RP2040 is automatically available on RP2350, or that every add-on has identical behavior across both families. The repository includes recent releases labeled as adding boards and Pico 2 builds, which indicates active compatibility work, but engineers should check the relevant example and product documentation rather than infer support from chip architecture alone.

Some product coverage is also asymmetrical. Pico Audio Pack is marked as C++ only, so a MicroPython user cannot assume access to every listed device. Other products have their own MicroPython firmware and examples in separate repositories, as the README warns. That division can create duplicate-looking resources and makes release selection a project-specific decision. The central repository is best treated as the shared Pimoroni support layer, not as the only place where board-specific software may live.

Maintenance, Licensing, and Adoption Constraints

The repository is not archived. Its last push was on 2026-10-14. Recent releases include v1.29.0 on 2026-08-26, v1.29.0-1 on 2026-08-28, and v1.29.0-2 on 2026-08-31. The release titles specifically mention additional boards and working Pico 2 builds. This is evidence of recent project work, although release activity does not guarantee compatibility with every board revision or accessory.

The repository is licensed under MIT. That identifier permits use and modification under the terms of the license, but this review does not replace the license text or provide legal advice. Engineers should inspect `LICENSE` when integrating the code into a product and account for the separate licensing of firmware, hardware documentation, and any external dependencies.

Upgrade cost depends on the chosen path. Prebuilt MicroPython users mainly face new firmware images, board changes, driver fixes, and application compatibility. C/C++ users face the same changes at source and build level, potentially including SDK or CMake adjustments. Product-specific repositories add another consideration: users of products with dedicated firmware must track those repositories as well. The repository is a good fit for supported hardware, but the adoption boundary is narrower than the word "Pico" might suggest.

Pimoroni Pico Compared with Upstream Pico Software

Pimoroni Pico differs from upstream Raspberry Pi Pico software mainly in hardware scope and convenience. Pimoroni Pico adds drivers, examples, firmware builds, and product knowledge for Pimoroni boards and Breakout Garden sensors. A generic Pico project that does not use this hardware may gain little from importing this repository.

The MicroPython route packages selected drivers into a vendor-provided firmware image. Pimoroni supplies this custom firmware through its releases. Pimoroni's route is more direct for a listed display, pack, or breakout because the documentation points to drivers already built into the supplied image.

The C/C++ route has a similar distinction. Pimoroni's examples and libraries encode support for named devices and boards. The trade-off is specialization. Vendor support reduces guesswork for supported products, but it also means that the central repository is not the authoritative driver source for every connected device.

Editorial conclusion

Adopt this repository when your board, add-on, or Breakout Garden sensor appears in its supported product list and you want Pimoroni's C/C++ or prebuilt MicroPython path. Do not assume that every newer peripheral or generic Raspberry Pi Pico accessory is covered. Verify first that your exact board and chip generation are listed, then follow `setting-up-micropython.md` for firmware installation or `setting-up-the-pico-sdk.md` for a compiled C/C++ build.

Frequently asked questions

Official sources

1. License: MIT
2. pimoroni/pimoroni-pico on GitHub
3. Project website
4. README
5. Releases