The STM32 Arduino core shipped version 3.0.0 while its own introduction still says IDE 2.x
STM32 core support for Arduino
At a glance
- What is it?
- A C core that adds STM32 microcontroller support to Arduino IDE 2.x, built on ST's HAL and the GNU Arm toolchain delivered through xPack. The newest release is 3.0.0 from July 2026, per-board release dates in the support table go back to 0.1.0, the framework manifest declares version 0.0.0 under a different name, and two build systems are maintained in parallel.
- Who is it for?
- Arduino_Core_STM32 is the right dependency when you want to develop against ST hardware from the Arduino IDE without leaving the Boards Manager, because the support is packaged as an ordinary board manager package, the hardware abstraction comes from ST's own HAL rather than a reimplementation, and the compiler and debugger arrive as pinned xPack builds so a machine without a system Arm toolchain still works. Three things to know before you start.
- 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 last received commits 3 days ago.
- What is it written in?
- Mainly C, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.
Star history
- stm32duino/Arduino_Core_STM323,383 ★ · +25
| Repository | 2026-09-24 | 2026-11-15 |
|---|---|---|
| stm32duino/Arduino_Core_STM32 | 3.4k | 3.4k |
25 Stars in the last 52 days, measured from the daily GitHub snapshot. Compare with other projects
Editorial analysis
Version 3.0.0 shipped while the introduction still says IDE 2.x
The release history is 2.11.0 in July 2025, 2.12.0 in December of that year, and then 3.0.0 in July 2026, so the project has just made a major version step after more than a decade on the 2.x line. The introduction paragraph has not moved with it and still describes the repository as adding STM32 microcontroller support in Arduino IDE 2.x. The README also carries a comparison badge pointing from 3.0.0 to main, which is how you can tell the default branch is ahead of the newest tag rather than equal to it; the most recent push to main is dated 2026-10-02. The other support statement that matters is a warning saying that since core release 2.8.0 only Arduino IDE 2 is supported, which is the constraint that decides whether this core is usable in your setup at all.
Per-board release dates go back to 0.1.0
The support table does not have a version column in any ordinary sense. Each board row names the core release in which that board's support first appeared, and those releases span most of the project's history: the first visible Nucleo rows list 0.2.0, 2.6.0, 2.4.0, 0.1.0, 2.8.0, 2.7.0, 2.4.0 and 1.4.0. Read as a feature history rather than a compatibility matrix, that is useful, because it tells you how long a given board has been carried and whether it was added recently. Read as a version table it is misleading, since a board that says 0.1.0 is not an ancient board, it is a board whose support has been in every release since the beginning. Anyone skimming this table for a version to pin against will misread it.
Two status markers mean some board support exists only on main
The table carries a two-state legend explained in a note below the list of families. One marker means board support has been available since the release named in that row. The other means the support is available in the main branch and will be available in the named release. That second state is the one to plan around: it describes code that exists in the repository but is in no installable release, so a user who adds boards through the Boards Manager does not have it, while someone tracking the git repository directly does. The families covered run from the Nucleo, Discovery and Eval boards through a long list of generic families, and include 3D printer, brushless motor driver, flight controller, LoRa and IoT continuum groups, which is a better indication of who uses this core than the count of supported parts.
The framework manifest declares version 0.0.0 under another name
The repository root holds a package manifest with four fields. Its name is framework-arduinoststm32, which does not match the repository name Arduino_Core_STM32. Its description calls it the Arduino Wiring-based Framework for the STM32 core. Its version is the constant 0.0.0, and its URL points back at this repository. That manifest is not what installs the core: installation goes through the Arduino Boards Manager using an index file hosted in a separate repository, stm32duino/BoardManagerFiles, whose URL you paste into the Additional Boards Manager URLs field. So there are two identities for this project, one for the Arduino tooling and one for the framework manifest, and the version field in the manifest carries no release information at all. Read the release tags or the board table instead.
Two build systems and four workflows
There is an Arduino build and a CMake build, with a separate README for the latter and a cmake directory at the root, so both paths are documented rather than one being an accident. Four workflows run on every change: a build workflow, a CMake workflow, a spell checker and the official Arduino linter. The Arduino linter is the interesting one, because it is the tool that validates the metadata files that make a board usable at all, and those files sit at the root as plain text, a boards definition, a platform definition, a programmers definition and a keywords file. The spell checker in that list is there because the tree is full of board and vendor names that a general dictionary would reject. A security policy and a contributing guide are also present, along with an editor configuration.
The toolchain arrives through xPack, not a system compiler
The port sits on three foundations, and the third is the one that saves you an afternoon. Hardware access comes from ST's own STM32Cube MCU packages, using the standard HAL for portability across devices, the low-layer APIs as a lighter path, and CMSIS device definitions. Above that sits ARM's CMSIS, described as a vendor-independent hardware abstraction for the Cortex-M family, packaged for the Arduino IDE as its own Arduino module in a separate repository. The compiler is the GNU Arm Embedded Toolchain, and it is not taken from the system: packages come from the xPack third-party development tools organisation, one repository for the compiler and another for the debugger. So a machine with no Arm GCC installed still builds this core, at the cost of a large download.
The family list is out of order and the table ends mid-cell
Two small things in the board section are worth knowing before you use it as a reference. The generic families are not listed in series order: the wireless entries run WB, then WB0, then WBA, then WL3, then WL, which puts the WL3 part before its own WL predecessor. And the visible portion of the table stops partway through a row, on the release number of one Nucleo board, so the rest of that row and every table after it are not present in the text available here. Adding a board yourself is supported through a wiki page, so the family list is not a closed set, and an advanced user can install from the git repository instead of the board manager to get the main-branch builds those status markers describe.
Editorial conclusion
Arduino_Core_STM32 is the right dependency when you want to develop against ST hardware from the Arduino IDE without leaving the Boards Manager, because the support is packaged as an ordinary board manager package, the hardware abstraction comes from ST's own HAL rather than a reimplementation, and the compiler and debugger arrive as pinned xPack builds so a machine without a system Arm toolchain still works. Three things to know before you start. Only IDE 2 is supported, and that has been true since core release 2.8.0, so an IDE 1 workflow is gone rather than deprecated. Board availability has two channels, and a board marked as main-only does not exist in any release you can install from the board manager. And the project keeps both the Arduino build and a CMake build, so pick one and do not expect a single build command to cover both.
Frequently asked questions
Which Arduino IDE versions work with the STM32 core?
Only Arduino IDE 2. The project has stated that since core release 2.8.0, IDE 1 is no longer supported.
How do I install the Arduino core for STM32?
Add the board manager index URL from the stm32duino/BoardManagerFiles repository to the Additional Boards Manager URLs field in the IDE, then install the package through the Boards Manager. Advanced users can build from the git repository instead to get main-branch code.
Do I need to install an Arm compiler separately?
No. The GNU Arm Embedded Toolchain and the debugger are provided as xPack packages rather than taken from the system, so the toolchain comes with the project.
What license is the Arduino core for STM32 released under?
The repository licence field carries no recognisable value, and the root holds a file named License.md rather than the usual LICENSE file. The terms are in that file rather than in the README.
Which STM32 boards does the Arduino core cover?
Nucleo, Discovery and Eval boards, STM32MP1 coprocessor boards, a long list of generic families from C0 through WL, and vendor groups covering 3D printers, brushless motor drivers, flight controllers, LoRa and IoT continuum boards. New variants can be added by following the project wiki.
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)Star history chart for your README
[](https://hysenlabs.com/projects/stm32duino-arduino-core-stm32)Was this useful?