Get started without a complex setup
A practical guide to first launch, native ESP32 Coder projects, and importing Arduino IDE and PlatformIO projects.
Run from a dedicated folder
ESP32 Coder folder. On the latest GitHub release page, choose the ZIP file. The separate .exe release asset is intended for automatic updates. Never run the app directly from the archive or a temporary directory: components, caches, projects, and settings need a permanent writable folder.- Open the latest ESP32 Coder release and download the ZIP archive.
- Create a permanent parent folder, such as
C:\Dev\, preferably outside OneDrive. - Extract the complete
ESP32 Coderfolder from the ZIP into it. The app will be atC:\Dev\ESP32 Coder\. - Run
esp32coder.exefrom that folder. Keep the entire working directory together; the standalone EXE release asset is reserved for the automatic update workflow.
C:\Dev\ESP32 Coder\
├── esp32coder.exe
├── runtime\ (components)
├── Projects\
│ └── MyProject1\
│ ├── libs\
│ ├── MyProject1.cpp
│ └── esp32coder.ini
└── build_temp\ (may be created on build)The build_temp directory is normally created alongside the app when building. For Unicode or OneDrive paths, Coder may relocate temporary build files to a local Windows directory.
Avoid Program Files unless the directory is writable. ESP32 Coder creates Projects automatically.
Select a board and install components
- Launch ESP32 Coder and choose your board from Board / Port. Use ESP32 Dev Module for the examples.
- Open Components and install the required SDK/Arduino Core and toolchain for the selected board.
- If required, open Libraries and install any missing external dependencies.
- Connect your board using a data-capable USB cable and select its COM port.
An internet connection is needed for the initial component download. Once installed, local editing, compilation and flashing can work offline.
Open a native ESP32 Coder example
The ESP32_Smart_Monitor example contains eight source files for a Wi-Fi access point, a small HTTP/JSON status endpoint, ADC sampling, and Preferences-based settings. Its ZIP now includes esp32coder.ini and libs/, which make it a native Coder project.
ESP32_Smart_Monitor/
├── libs/ ← project-local libraries
├── ESP32_Smart_Monitor.cpp
├── AppConfig.h
├── SensorHub.h
├── SensorHub.cpp
├── WebDashboard.h
├── WebDashboard.cpp
├── SettingsStore.h
├── SettingsStore.cpp
└── esp32coder.ini ← project configurationCoder creates the project folder and libs/, but not src/ or include/. The source and header files in this example sit directly in the project root.
New projects can use the same automatic library cleanup: after a successful build, Coder keeps the used libraries and their dependencies in libs/.
- Download the native ESP32 Coder project ↓.
- Extract
ESP32_Smart_MonitorintoC:\Dev\ESP32 Coder\Projects\or another permanent workspace. - In Coder, choose Open → Open project and select
ESP32_Smart_Monitor. - Select ESP32 Dev Module and choose Check or Build.
GPIO34 on a classic ESP32 Dev Module. Change the pin for ESP32-S3/C3 and other boards; verify hardware compatibility. Hardware testing of this example has not been performed.Expected Serial Monitor output (115200 baud)
The firmware prints a ready message on startup. With logging enabled (the default), every 250 ms it prints the ADC voltage on GPIO34 and the exponentially filtered average:
[SmartMonitor] System ready
ADC: 1.50 V | Avg: 1.50 V
ADC: 1.55 V | Avg: 1.51 V
ADC: 1.60 V | Avg: 1.52 V
ADC: 1.68 V | Avg: 1.54 V
These numbers are calculated from illustrative ADC input values using the SensorHub algorithm. On an actual ESP32 they depend on GPIO34 voltage. This example does not print Wi-Fi SSID, IP address, or HTTP status over Serial.
Import an Arduino sketch
ESP32 Coder imports the whole sketch folder containing the main .ino file, rather than just an editor selection.
Arduino_Blink_Serial/
├── Arduino_Blink_Serial.ino
└── BlinkConfig.h
#include <Arduino.h>
#include "BlinkConfig.h"
void setup() { Serial.begin(115200); pinMode(LED_PIN, OUTPUT); }
void loop() { digitalWrite(LED_PIN, HIGH); delay(500); digitalWrite(LED_PIN, LOW); delay(500); }
- Download the Arduino import example ↓ and extract it outside Coder's Projects directory.
- Choose Open → Import Arduino IDE project.
- Select the
Arduino_Blink_Serialfolder containing the .ino file. - Set a new project name and confirm. The imported project appears under
Projects/. - Confirm the board and dependencies, then choose Check or Build.
esp32coder.ini. Your Arduino IDE original is left unchanged.For larger Arduino sketches, you can copy the shared Arduino libraries into libs/ and automatically prune unused libraries after a successful build. This also works for new projects.
Import a PlatformIO project
Select the root project folder containing platformio.ini, not src/ by itself.
This is the original PlatformIO layout, not the resulting Coder project:
PlatformIO_Blink_Serial/
├── platformio.ini
├── src/
│ └── main.cpp
└── include/
└── BlinkConfig.hAfter importing into Coder, main.cpp and BlinkConfig.h are placed in the new project root; Coder also creates esp32coder.ini and libs/.
[env:esp32dev]
platform = espressif32
board = esp32dev
framework = arduino
monitor_speed = 115200
- Download the PlatformIO import example ↓ and extract it outside the Coder workspace.
- Choose Open → Import PlatformIO project.
- Select the
PlatformIO_Blink_Serialfolder withplatformio.ini. - Confirm the new name. Coder copies source files, compatible board settings and dependency information into a native project.
- Confirm the board and libraries, then choose Build.
platformio.ini is read for settings but is not copied into the Coder project. Coder creates esp32coder.ini instead. Local lib/ libraries and available .pio/libdeps/ caches may be copied into libs/; install any missing libraries separately.Import Arduino libraries into libs and remove unused packages
ESP32 Coder keeps third-party libraries inside each project. Every library has its own subfolder under libs/, alongside the source files and esp32coder.ini. This makes projects easier to move between computers without relying on a separate global Arduino IDE library installation.
libs/ first. After the first successful compilation, Coder automatically removes project libraries that are not used by the current code or required by other dependencies. The same workflow also works for new Coder projects.1. Import libraries into a project
- Open or create a project in ESP32 Coder. If you are migrating an Arduino sketch, import the folder containing the main
.inofirst. - Open Libraries and choose the Arduino IDE library-folder import. Select the shared folder containing individual library subfolders, for example
C:\Users\<user>\Documents\Arduino\libraries, or your custom Arduino libraries location. - Confirm and allow the copy to finish. Coder places the imported libraries in the current project's
libs/directory, shows copy progress, and does not pre-filter all files by ESP32 architecture. - Inspect
libs/in the project tree. A normal copy-based import leaves the original Arduino IDE library directory unchanged.
Projects/
└── MyProject1/
├── MyProject1.cpp
├── esp32coder.ini
└── libs/
├── ArduinoJson/
├── ESP_Async_WebServer/
├── Async_TCP/
└── Some_Unused_Library/ ← initially copied too
You can also install individual libraries through the Libraries manager, search GitHub, or copy library folders directly into libs/. Libraries already shipped with ESP32 Arduino Core usually do not need separate installation.
2. What happens after the first successful build
- Choose the target board and click Build (or complete a full Check that successfully compiles). Coder examines
#includedirectives, library headers, and dependencies between libraries. - Coder compiles and links the project. Cleanup runs only after successful compilation and linking, and after BIN generation for a Build operation. Libraries are not deleted when the operation fails or is cancelled.
- Libraries used directly or transitively are retained. Recognized unused library folders are removed from the project only (normally
libs/; cleanup can also cover project-locallib/and.pio/libdeps/). - The Output console shows
LIBRARY CLEANUP REPORT AFTER SUCCESSFUL VERIFY/BUILD, including the number of libraries scanned, removed, and kept. You can reinstall or reimport a library later if needed.
MyProject1/
├── MyProject1.cpp
├── esp32coder.ini
└── libs/
├── ArduinoJson/
├── ESP_Async_WebServer/
└── Async_TCP/ ← required dependency retained
libs/ before the first successful build. A normal copy-based import does not remove libraries from the shared Arduino IDE folder.3. Use the same workflow for new projects
- Create a new project, for example
MyProject2. Coder creates the project folder andlibs/. - Add likely dependencies using Libraries or copy folders into
libs/. - Write your code with the necessary
#includedirectives and complete the first successful Build. - Review the cleanup report: Coder retains used libraries and their dependencies, removing the recognized extras.
If you later add a new module or #include, install the missing library into libs/ and build again. This keeps the project portable and avoids carrying your entire Arduino IDE library collection.
Check, build and flash
Inspect project configuration and dependencies without flashing.
Compile and generate a firmware BIN.
Build and flash using the selected COM port.
For debugging, open Serial Monitor and Plotter. Match its baud rate to Serial.begin(...); these examples use 115200.
Common questions
SDK or toolchain missing
Select your target board and open Components. Install the correct package for that ESP32 family, then retry the build.
Importer cannot find .ino or platformio.ini
Select the project root: a folder containing the main .ino for Arduino IDE or platformio.ini for PlatformIO.
COM port missing
Check the USB cable, USB-UART driver and whether another serial monitor has claimed the port. Refresh the port list.
Projects or cache do not persist
Run the unpacked application from a dedicated writable folder, never from the ZIP or a temporary archive directory.
