# arduino-pico: the RP2040 and RP2350 Arduino core explained

> earlephilhower/arduino-pico ports the Arduino API to every RP2040 and RP2350 board, adding Bluetooth, WiFi, Ethernet, OTA and FreeRTOS SMP. Here is how it installs, what it costs you in flash and toolchain terms, and where it stops being the right choice.

**earlephilhower/arduino-pico** — Raspberry Pi Pico Arduino core, for all RP2040 and RP2350 boards

- Repository: https://github.com/earlephilhower/arduino-pico
- Stars: 2,875 · Forks: 567
- Language: C
- License: LGPL-2.1
- Published: 2026-09-28 · Updated: 2026-09-28 · Language: en
- Canonical page: https://hysenlabs.com/projects/earlephilhower-arduino-pico

## What arduino-pico actually replaces

The RP2040 and RP2350 ship with the Raspberry Pi Pico SDK, a C SDK with its own build system and its own idea of how a program starts. arduino-pico puts the Arduino API on top of that SDK. The README describes it as a port of Arduino to the RP2040 and RP2350 that uses the bare Raspberry Pi Pico SDK with a custom GCC 16.1 and Newlib 4.6 toolchain, and it supports both the ARM cores and the RISC-V (Hazard3) cores on the RP2350.

The audience is narrow and specific. If you already write Arduino sketches and you have a Pico, a Pico W, a Pico 2, a Pico 2W or one of the roughly 130 third-party boards the README lists, this core lets you keep setup() and loop() and still reach the hardware. If you are writing bare-metal C against the Pico SDK, this core adds a layer you do not need. The supported board list is the real signal here: it runs from the Raspberry Pi first-party boards through Adafruit, SparkFun, Pimoroni, Seeed, Waveshare, WIZnet and a long tail of small vendors, plus generic RP2040 and RP2350 targets with configurable flash and I/O pins. That breadth is the project's main selling point, and it is also a maintenance burden the release notes keep paying down.

## Multicore, PIO and the parts that are not standard Arduino

The mechanism that matters most is how the core splits work across the two Cortex-M0+ cores on the RP2040 (and the equivalent on the RP2350). arduino-pico adds setup1() and loop1() alongside the usual setup() and loop(). Your second core runs its own setup and its own loop, which means you can put a time-critical task on core 1 and leave the Arduino main loop alone. That is a different model from the interrupt-driven approach most Arduino cores push you toward, and it changes how you think about shared state between the two loops.

The second mechanism is the PIO. The README states that the RP2040 PIO state machines are used to generate jitter-free servos, tones, I2S input and output, software UARTs and software SPIs. In practice this means those peripherals do not consume CPU time or timer interrupts the way a bit-banged implementation would. It also means the number of PIO state machines is a real budget: if your sketch needs several software serial ports plus I2S plus servos, you are competing for the same small pool of state machines, and the README does not offer a table showing how many each feature consumes.

On top of that sit the connectivity stacks: Bluetooth Classic and BLE on the Pico W including HID master mode and A2DP audio source and sink, WiFi via the Pico W, an ESP32-based ESPHost or an Atmel WINC1500, wired Ethernet via WIZnet W5100, W5500, W6100, W6300 and ENC28J60 parts, an HTTP client and server, SSL/TLS, OTA upgrades, LittleFS and SD filesystems, and FreeRTOS SMP support. Each of those is compiled in only when you use it, but each one also adds to the surface area you are trusting.

## Installing arduino-pico from the Arduino Boards Manager

The README documents installation through the Arduino Boards Manager, and the repository carries the package.json that names the framework package as framework-arduinopico. The README does not reproduce the Boards Manager URL in the excerpt available, so the reliable path is the documentation site it points to at arduino-pico.readthedocs.io, which the README names as the place for detailed usage information alongside the bundled examples.

Once the core is installed, the smallest useful sketch is the standard Arduino one, because the core keeps the familiar entry points. The README does not print a sketch, so the entry points below are the ones it names in its feature list:

```cpp
void setup() {
}

void loop() {
}
```

If you want the second core, the README's feature list gives you the two extra entry points to add in the same file:

```cpp
void setup1() {
  // runs once on the second core
}

void loop1() {
  // runs continuously on the second core
}
```

Two platform warnings come straight from the README and are worth repeating because they cause silent failures. On Windows, do not use the Windows Store build of the Arduino IDE, because the README says it has issues detecting attached Pico boards; use the Windows ZIP or the plain EXE from arduino.cc and let it install the device drivers it suggests. On Linux, a flatpak install restricts access to the host, and the README shows the symptom as an upload that ends in "No drive to deploy." after scanning for RP2040 devices. The fix is to install Arduino another way or override the flatpak sandbox.

## Where arduino-pico is the wrong tool

The clearest limitation is the toolchain. The core carries its own GCC 16.1 and Newlib 4.6 build, and release 6.0.0 is described in the release notes as bringing GCC 16.1, SDK 2.3.0, Newlib 4.6.0 with Nano-Printf, and C23/C++23. A custom toolchain is what lets the project track new language standards ahead of the stock SDK, but it also means the compiler you get is the compiler the maintainer ships. If your organisation pins a specific GCC version for compliance reasons, that pin does not survive here.

Second, the RP2350 RISC-V path is a choice you make at build time, not something you can switch at runtime. The README lists ARM or RISC-V (Hazard3) support for the RP2350 as a feature, which implies a per-target selection. If your firmware assumes ARM-specific inline assembly or a prebuilt binary blob, that selection is not free.

Third, the feature list is not a promise about every board. Bluetooth is listed for the Pico W, WiFi for the Pico W, ESPHost and WINC1500, Ethernet for specific WIZnet and Microchip parts, and PSRAM globals and heap are RP2350 only. A generic RP2040 board with no radio will not gain Bluetooth because the core supports it somewhere else. If your board is one of the generic targets, check the variant rather than assuming the feature list applies.

Finally, the README does not document rollback. There is no described procedure for returning to a previous core version after an upgrade breaks a build, beyond reinstalling from the Boards Manager. That is a real gap for anyone shipping firmware.

## How it compares with the official Arduino Mbed core and with PlatformIO

The obvious alternative for RP2040 boards inside the Arduino IDE is the official Arduino Mbed-based core for the Nano RP2040 Connect and the Pico. The difference in approach is the foundation: arduino-pico sits directly on the Raspberry Pi Pico SDK, while the Mbed core sits on Mbed OS. That distinction shows up in the feature list. arduino-pico exposes PIO state machines for jitter-free servos, tones, I2S and software serial, and it exposes setup1() and loop1() for the second core, because those are Pico SDK concepts the core chose to surface rather than hide.

The other path is PlatformIO, which is a build system rather than a core. PlatformIO wraps the same framework package, and package.json in this repository identifies it as framework-arduinopico, so a PlatformIO project using that framework is using this code. The difference is who owns the build: PlatformIO gives you a platformio.ini and a reproducible command-line build, while the Arduino IDE gives you the Boards Manager flow the README documents. If your team already builds in CI, the PlatformIO route is the one that fits, and the Arduino IDE route is the one the README describes.

## Licence and the upgrade treadmill

The repository is licensed LGPL-2.1. That is a copyleft licence with a linking exception tradition, and it applies to the core, not to your sketch. The practical question for a commercial product is what happens when you statically link the core and the bundled libraries into a firmware image, which is the normal outcome for embedded work. The repository also vendors ArduinoCore-API, FreeRTOS-Kernel and pico-sdk as submodules, and those carry their own licences. Read the LICENSE file and the submodule licences before you ship; nothing here is legal advice, and the answer depends on how you distribute the binary.

Upgrade cost is the other half. The release cadence visible in the release list is roughly monthly: 6.0.0 on 2026-07-21, 6.1.0 on 2026-09-04, 6.1.1 on 2026-09-21. The last push to the default branch was on 2026-09-23. Major versions are not cosmetic: 6.0.0 moved the compiler, the SDK and the C/C++ standards in one step, which is exactly the kind of change that surfaces warnings in sketches that previously compiled clean. Budget for a rebuild-and-test pass on every major bump, and treat the minor releases as the safer place to pick up board support.

## What to check before you commit

Start with the board list. The README enumerates every supported board by name, and if yours is not there, the generic RP2040 or generic RP2350 target with configurable flash and I/O pins is the fallback, which means you configure the flash size and pin mapping yourself rather than inheriting a variant. That is more work than it sounds.

Next, decide whether you need the connectivity features at all. If you only need digital I/O, PWM, ADC and a serial port, the extra stacks in the core are code you are not running but are still carrying in the repository and in your mental model of the build. If you do need them, note that the README scopes Bluetooth and WiFi to the Pico W family and lists the specific Ethernet chips supported, so the wireless story depends on which radio is on your board.

Then check the toolchain against your constraints. GCC 16.1 and Newlib 4.6 with Nano-Printf and C23/C++23 is a modern baseline, and it is also a baseline you inherit wholesale. If you have a firmware bill of materials that pins compiler versions, this core is a deliberate exception to it, and you should document that exception rather than discover it during an audit.

## Conclusion

Adopt arduino-pico if you are writing Arduino sketches for an RP2040 or RP2350 board and want Bluetooth, WiFi, Ethernet, OTA or multicore support without leaving the Arduino IDE. Do not adopt it if you need a vendor-supported toolchain with a commercial SLA, or if your project cannot accept LGPL-2.1 obligations on the core and the bundled libraries. Before committing, verify three things on your own hardware: that your exact board appears in the supported list in the README, that your Arduino IDE is the plain Windows EXE or ZIP build rather than the Windows Store or flatpak version, and that your sketch still fits in flash after the core and its libraries are linked. The release notes for 6.1.1 are the first place to check for board additions that landed after your last install.

## FAQ

### What is arduino-pico?

It is the Raspberry Pi Pico Arduino core maintained by earlephilhower, described in the README as a port of Arduino to the RP2040 and RP2350 that uses the bare Raspberry Pi Pico SDK with a custom GCC 16.1 and Newlib 4.6 toolchain. It targets all RP2040 and RP2350 boards, from the first-party Pico, Pico W, Pico 2 and Pico 2W to a long list of third-party boards.

### How do I install the arduino-pico core?

The README documents installing via the Arduino Boards Manager and points to arduino-pico.readthedocs.io for detailed usage information. On Windows, use the ZIP or plain EXE build from arduino.cc rather than the Windows Store version, which the README says has trouble detecting Pico boards; on Linux, a flatpak install can cause uploads to fail with "No drive to deploy."

### Can arduino-pico use both cores on the RP2040?

Yes. The README lists multicore support as a feature and names the entry points setup1() and loop1(), which run on the second core alongside the usual setup() and loop(). FreeRTOS SMP support is also listed as a separate feature.

### Does arduino-pico support Bluetooth and WiFi?

The README lists Bluetooth Classic and BLE on the Pico W, including HID master mode and A2DP audio source and sink, and WiFi on the Pico W, an ESP32-based ESPHost and an Atmel WINC1500. Those features are tied to the radio on your specific board, so a generic RP2040 target without a radio does not gain them.

### What licence is arduino-pico released under?

The repository is licensed LGPL-2.1. It also vendors ArduinoCore-API, FreeRTOS-Kernel and pico-sdk as submodules, and those carry their own licences, so check the LICENSE file and the submodules before distributing a firmware image.

## Sources

- [earlephilhower/arduino-pico on GitHub](https://github.com/earlephilhower/arduino-pico)
- [Issues](https://github.com/earlephilhower/arduino-pico/issues)
- [License: LGPL-2.1](https://github.com/earlephilhower/arduino-pico/blob/master/LICENSE)
- [README](https://github.com/earlephilhower/arduino-pico/blob/master/README.md)
- [Releases](https://github.com/earlephilhower/arduino-pico/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/earlephilhower-arduino-pico