Arduino_Core_STM32: running the Arduino API on STM32 boards
STM32 core support for Arduino
At a glance
- What is it?
- STM32duino's core brings the Arduino API to STM32 microcontrollers through STM32Cube HAL and LL drivers, installed from a Boards Manager URL. It is broad in board coverage and thin on rollback guidance.
- Who is it for?
- Adopt Arduino_Core_STM32 if you want Arduino-style sketches on STM32 hardware and you are already on Arduino IDE 2.x; the boards list spans Nucleo, Discovery, Eval, 3D printer, flight controller, LoRa and SparkFun boards, and the last push to the repository was on 2026-09-22.
- Can I use it commercially?
- Check first. The repository uses a licence we do not classify automatically, so read its LICENSE file before any commercial use.
- Is it still maintained?
- Yes. The repository received new commits within the last day.
- What is it written in?
- Mainly C, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on September 30, 2026, and from our analysis. They are not legal advice.
Editorial analysis
What Arduino_Core_STM32 actually solves
Arduino's own cores cover AVR and a handful of other families. If you have an STM32 board on your desk and you want to keep writing setup() and loop(), the stock IDE has no target for it. This repository fills that gap: it is the STM32 core support package for Arduino, published under the stm32duino organization, and the README describes it plainly as adding support of STM32 MCU in Arduino IDE 2.x.
The audience is narrower than the board list suggests. It is for people who already think in Arduino terms and want STM32 silicon underneath, not for teams who want a vendor-neutral HAL or a full RTOS workflow. The porting sits on STM32Cube MCU Packages, which supply the HAL for portability between STM32 devices via standardized API calls, plus the Low-Layer (LL) APIs described as a light-weight, optimized, expert oriented set of APIs designed for both performance and runtime efficiency. CMSIS device definitions come along for the Cortex-M side. That stack choice is the whole character of the project: you get ST's silicon abstraction wearing Arduino's clothing.
How the core is layered and where your sketch sits
The dependency chain runs in one direction. Your sketch calls the Arduino API. The core translates that into STM32Cube HAL or LL calls. Below that, CMSIS device definitions describe the specific Cortex-M part, and the GNU Arm Embedded Toolchain compiles the result for bare metal. The README lists the toolchain packages as coming from The xPack 3rd Party Development Tools, specifically arm-none-eabi-gcc-xpack and openocd-xpack, with CMSIS packaged separately as a module for the Arduino IDE.
That layering explains most of the project's behaviour. Because the HAL is the portability layer, one sketch can move between an STM32F4 and an STM32H7 with fewer changes than a register-level port would need. Because the LL APIs are exposed as well, you can drop below the HAL where timing matters, at the cost of writing code that is tied to a specific series. The repository layout reflects the split: boards.txt, platform.txt and programmers.txt at the top level are the Arduino platform metadata, while cores/, libraries/, system/, variants/ and tools/ hold the implementation. The variants directory is where per-board pin mapping lives, which is why adding a new board is a documented wiki procedure rather than a config change.
Installing it from the STM32 Arduino board Manager URL
The README gives the Boards Manager route as the standard path. Open Arduino IDE 2.x, go to the preferences, and paste the STM32duino package index into the Additional Boards Managers URLs field. The exact URL from the README is below.
https://github.com/stm32duino/BoardManagerFiles/raw/main/package_stmicroelectronics_index.jsonAfter that, open the Boards Manager, search for STM32, and install the STM32 MCU based boards package. The index is what makes the core and its toolchain packages visible to the IDE; without it, no STM32 entry appears. Note the warning in the README: since core release 2.8.0, only Arduino IDE 2 is supported, so this step assumes IDE 2.
Once installed, select your board from Tools > Board. For a Nucleo F207ZG, for example, the README's Nucleo 144 table lists that device as supported since release 0.2.0. If you would rather track the main branch than a release, the README points advanced users to a wiki page titled Using git repository. For a board that is not in the list, there is a separate wiki page, Add a new variant (board).
Board coverage is the selling point, and the caveat
The supported boards section is long. It runs from Nucleo 144, Nucleo 64 and Nucleo 32 through Discovery and Eval boards, then into generic series entries covering STM32C0, C5, F0, F1, F2, F3, F4, F7, G0, G4, H5, H7, L0, L1, L4, L5, U0, U3, U5, WB, WB0, WBA, WL and WL3. Beyond ST's own hardware there are third-party categories: 3D printer boards, flight controllers, LoRa boards, SparkFun boards, Midatronics, Elecgator, ELV, STeaMi and others.
The tables carry a status convention that matters more than the length. A green heart means board support is available since the specified release version. A yellow heart means support is available in the main branch and will be available in the specified release version. Read that carefully before you buy hardware: a yellow-heart board is not in a released core yet, so the Boards Manager install will not give you what the main branch has. The README also notes the STM32MP1 series coprocessor boards as a separate category, which is a different kind of target from the Cortex-M devices and worth checking against your use case.
Where this core is the wrong choice
The README does not document rollback. If you upgrade the core and a peripheral driver regresses, there is no stated procedure for returning to the previous version. That is a real operational gap for anyone shipping firmware, and it is the kind of thing you want to know before, not after, a release lands.
The IDE 2-only rule is the second boundary. Anyone maintaining a build on Arduino IDE 1.x is out, and the README states the cutoff as core release 2.8.0 rather than leaving it ambiguous. Third, the core is a porting layer, not a replacement for ST's own ecosystem. If your project depends on STM32CubeMX-generated initialization, RTOS scheduling, or vendor middleware that the Arduino core does not wrap, you will spend your time bridging two worlds. And if you need a formally specified, versioned API contract with long-term support commitments, the Arduino core model is not that: it tracks a fast-moving upstream and its own release cadence, with 3.0.0, 2.12.0 and 2.11.0 as the recent releases.
How it differs from STM32CubeIDE and the vendor HAL alone
The obvious alternative is ST's own toolchain: STM32CubeIDE with STM32Cube MCU Packages, which is the same HAL and LL layer this core builds on, minus the Arduino API. The difference in approach is the entry point. With CubeIDE you configure peripherals through a graphical tool, generate initialization code, and write against the HAL directly; you get the full vendor surface and the full vendor complexity. With Arduino_Core_STM32 you get setup() and loop(), a smaller API, and a curated set of libraries, but you give up direct control over initialization and you inherit the core's board definitions rather than your own.
A second alternative is writing bare-metal against CMSIS with the same GNU Arm Embedded Toolchain. That path removes the HAL overhead entirely and gives you exact control, which is what the LL APIs gesture at but do not fully deliver. It also removes every convenience the core provides. The trade is consistent across both alternatives: this core optimizes for getting a sketch onto STM32 hardware quickly, not for squeezing the last cycle out of it.
Maintenance, releases and licence status
The repository is not archived, and its last push was on 2026-09-22. Recent releases are 3.0.0 on 2026-07-23, 2.12.0 on 2025-12-16 and 2.11.0 on 2025-07-28, so the project is publishing on a roughly semi-annual cadence with a major version bump in the most recent cycle. The CI surface is visible in the README badges: an Arduino build workflow, arduino-lint, codespell and a CMake workflow. A major version bump is the thing to watch when planning an upgrade, since it is the release most likely to change behaviour.
On licensing, the repository's license field resolves to NOASSERTION, and there is a License.md file at the top level. That means the licence terms are not machine-classified and you should read License.md yourself rather than assume. The core also pulls in third-party components with their own terms: STM32Cube MCU Packages, CMSIS, the GNU Arm Embedded Toolchain, and xPack-packaged builds of arm-none-eabi-gcc and openocd. If you redistribute firmware built with this core, the obligations of those upstream components are part of your problem, not just this repository's. This is a description of what is in the repository, not legal advice.
Editorial conclusion
Adopt Arduino_Core_STM32 if you want Arduino-style sketches on STM32 hardware and you are already on Arduino IDE 2.x; the boards list spans Nucleo, Discovery, Eval, 3D printer, flight controller, LoRa and SparkFun boards, and the last push to the repository was on 2026-09-22. Do not adopt it if you are pinned to Arduino IDE 1.x, since the README states that only IDE 2 is supported since core release 2.8.0, or if you need a documented downgrade path, because the README does not document rollback. Before committing, verify that your exact board appears in the supported boards tables with a green heart, and confirm the toolchain packages resolve in your environment.
Frequently asked questions
Why use STM32 instead of Arduino?
The README does not make a comparison argument. What it shows is that this core lets you keep the Arduino API while targeting STM32 MCUs, so the choice is about which silicon you want underneath the same sketch structure rather than about replacing Arduino programming.
Is STM32 a microcontroller or a processor?
The repository treats STM32 as microcontrollers. The README describes CMSIS as a vendor-independent hardware abstraction layer for the Cortex-M processor series and lists the GNU Arm Embedded Toolchain for bare-metal software development on Arm Cortex-M devices.
Is STM32 harder than Arduino?
The README does not answer this directly. It does note that the LL APIs are described as expert oriented, and that adding a new board requires following a wiki procedure, which suggests the surface is broader than a stock Arduino board.
Official sources
Add this badge to your README
If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.
[](https://hysenlabs.com/projects/stm32duino-arduino-core-stm32)