On October 19, 2026, PlatformIO released version 8.0.0 of its official espressif32 platform. It ships ESP32 Arduino core 3.3.12, built on ESP-IDF 5.5.5. In PlatformIO’s words, “ESP32 Arduino Core v3 (based on ESP-IDF v5.x) is now supported in the official platformio/espressif32 development platform.”
Until now, a common way to get core v3 in PlatformIO was to point your project at the community pioarduino platform. Blynk’s own PlatformIO Edgent example did exactly that. With 8.0.0 you can use the standard platform line and get the current core and its newer toolchain.
The Blynk library has changed recently too. Version 1.3.5 improved compatibility with ESP32 Arduino core v3, and 1.4.0 (October 6) moved Blynk.Edgent, the part that handles WiFi provisioning and over-the-air updates, into its own library. So an Edgent project now lists both libraries.
This guide gives you one platformio.ini that builds, flashes and provisions an ESP32 with Blynk.Edgent on core v3. We ran it on an ESP32 DevKit before writing this. The last section shows the same project set up by Claude Code through the Blynk MCP server, since PlatformIO’s announcement also points at AI agents: “With a single configuration file, PlatformIO handles frameworks, toolchains, build flags, and board targets in a consistent and reproducible way. This also makes it a good fit for AI coding agents and other AI-powered development tools.”
Every Blynk device belongs to a template, which defines its datastreams, events and dashboard. In the Blynk Console, go to Developer Zone > My Templates and create a new template. Choose ESP32 as the hardware and WiFi as the connection type, and save it.
Copy the template ID (it starts with TMPL) and the template name. You’ll need both in the next step.
Keep the template name short. During provisioning the device advertises as “Blynk” plus the template name plus a short chip ID, and if the template name and chip ID together go over 32 characters, provisioning fails.
Create a new project for the esp32dev board, then replace platformio.ini with this:
What each part does:
platform = espressif32 @ ~8.0.0 is the official platform with core v3. The ~ picks up patch releases, which is what PlatformIO’s release notes suggest.
blynk-technologies/BlynkEdgent is the Edgent library. Since Blynk 1.4.0 it ships separately from the main Blynk library.
The five libraries after it are what Edgent and the example use. ArduinoJson and ArduinoHttpClient are the Edgent library’s own dependencies, NimBLE-Arduino handles Bluetooth provisioning, and OneButton and Adafruit NeoPixel drive the button and status LED in the example.
board_build.partitions = min_spiffs.csv gives the app more flash. An Edgent build with Bluetooth provisioning is about 1.7 MB, and this table has room for it (our build used 87%) while keeping two app slots for over-the-air updates.
The template flags in build_flags set your template ID and name at build time, so they don’t have to live in the sketch. Put single quotes around the whole flag, as PlatformIO’s docs recommend for string macros. Without them, a name with a space in it breaks the build.
Copy the Edgent ESP32 example into your project’s src folder. After the first build, PlatformIO has downloaded it to .pio/libdeps/esp32dev/Blynk/examples/Blynk.Edgent/Edgent_ESP32/. Copy all three files (Edgent_ESP32.ino, BoardConfig.h and Interaction.h) into src, rename the .ino file to main.cpp, and add this line at the top:
#include <Arduino.h>
Leave the commented-out BLYNK_TEMPLATE_ID and BLYNK_TEMPLATE_NAME lines in the sketch as they are, since build_flags now sets them. One line you’ll want to change over time:
#define BLYNK_FIRMWARE_VERSION "0.1.0"
This is the version Blynk.Air compares when you ship an update, so bump it with every release.
BoardConfig.h picks the pins for your board. For an ESP32 DevKit it uses GPIO 0 (the BOOT button) for reset and GPIO 2 for the status LED. Most ESP32 dev boards have an LED there, but not all.
From the project folder:
pio run -t upload
pio device monitor
pio run -t upload builds the firmware and flashes it. PlatformIO finds the serial port automatically; add --upload-port if you have more than one board plugged in. pio device monitor opens the serial console at 115200, the speed set by monitor_speed.
On a fresh board you should see "Blynk" along with the firmware version and the device info.
The WAIT CONFIG state means the device has no WiFi credentials yet and is waiting to be provisioned.
Open the Blynk app, tap Add New Device, then Find devices nearby. Your board shows up under the name from the serial log. Select it and enter your WiFi details.
Blynk.Edgent uses Bluetooth to set the device up, so the app can show the device’s real state and any error codes while it connects. The app sends the WiFi credentials and a new auth token, the device saves them and connects. The device then appears under your template in the Blynk Console and goes online. In our test it reported library 1.4.0, firmware 0.1.0 and board type ESP32 right away.
To start provisioning again, hold the BOOT button for 10 seconds, then release it. That clears the stored credentials.
When you change the firmware, bump BLYNK_FIRMWARE_VERSION and build again. The device ignores an update with the same version number as the one it’s running. PlatformIO writes the binary to
.pio/build/esp32dev/firmware.bin.
In the Blynk Console, go to Developer Zone > Blynk.Air (OTA) > New Shipping, choose your template or devices, and upload that file. Blynk.Air takes a .bin file, and firmware.bin is PlatformIO’s version of the binary the Arduino IDE exports. We shipped a 0.2.0 build to our DevKit this way: it downloaded the update, rebooted, and came back online reporting the new version. The Blynk.Air docs cover shipping options in more detail.
Most of the steps above are a call to Blynk or a command in PlatformIO’s CLI, so an AI coding agent can do them for you. Provisioning from the app is the one exception. Blynk hosts an MCP server at https://blynk.cloud/mcp, available on every Blynk plan, including free. It gives agents like Claude Code tools to create templates, datastreams and events, and to read devices and their values.
To connect Claude Code:
claude mcp add --transport http blynk https://blynk.cloud/mcp
Then run /mcp inside Claude Code and sign in to Blynk. Creating templates and datastreams needs Developer Mode on your account.
From there, one prompt covers everything except provisioning. For instance:
I have an ESP32 DevKit. Create a Blynk template called “Garden Monitor” with a temperature datastream on V1, then set up a PlatformIO project with Blynk.Edgent on espressif32 8.0.0, put the template ID in build_flags, build it and flash it.
The agent works in two places. Through the MCP server, the agent creates the template and datastreams in your Blynk account. Through the PlatformIO CLI, it writes platformio.ini and the sketch, runs pio run -t upload, and reads the serial monitor to check the device booted. You still provision the device from the app, since that’s where the WiFi credentials and auth token come from. After that, the agent can confirm the device is online with the MCP server’s get_device tool.
Blynk’s IoT cloud platform already handles the cloud side, the mobile app and OTA updates, so the agent only has to deal with the firmware.
The same platformio.ini should work for other ESP32 chips the platform supports, though we only tested the ESP32 DevKit. Blynk.Edgent supports the ESP32-S2, S3, C2, C3, C5 and C6, as well as ESP8266. Change the board, and check BoardConfig.h for your button and LED pins. The ESP32-S2 has no Bluetooth, so it falls back to WiFi access point provisioning there.
Once the device is online, add widgets to the template’s web and mobile dashboards, or ask the AI Assistant in the Blynk Console to build one. Blynk’s app builder can also publish those dashboards as a native iOS and Android branded IoT app for your customers, published to the App Store and Google Play under your own name at the Enterprise tier. Raypak (Raymote) and Windmill Air both ship their own branded apps on Blynk.
If the prototype is heading toward a product, Blynk also covers what goes around the device: user and organization management for your customers, role-based access, and SOC 2 Type II compliance. If you build on ESP-IDF instead of Arduino, Edgent is also available as a native ESP-IDF component.
Version 8.0.0 of PlatformIO’s espressif32 platform makes ESP32 Arduino core v3 available on the official platform, and the Blynk library 1.4.0 moved Edgent into its own library. Most of the setup lives in one platformio.ini: Edgent and its supporting libraries, the min_spiffs.csv partition table, and the template ID and name as build flags. With that, an ESP32 builds, flashes and provisions over Bluetooth, and an AI coding agent can do everything except provisioning through the Blynk MCP server and the PlatformIO CLI.
Create a free Blynk account and try it on your own ESP32.
.png)
