ESP8266-IDF

A convenient VS Code extension for developing with ESP8266-series chips.
Supports ESP8266_RTOS_SDK via idf.py.

Supported chips: ESP8266 (ESP8266EX), ESP8285 (ESP8285N08)

Requires Python 3.9 – 3.13 and works in any terminal shell (cmd.exe, PowerShell 5/7, bash, zsh, fish) on Windows, Linux and macOS — the extension bundles its own Python toolchain and manages the virtual environment automatically. See CHANGELOG for details.

Features

⚙ Menuconfig (web)

ESP › Menuconfig opens the project configuration in a VS Code panel:

• Search across option names, titles, and help text (CONFIG_…, wifi); press / to jump to the search box.
• All / Changed filter and Show hidden to reveal options whose dependencies are not met.
• ? button on each option with a description. It opens and closes the help: a short text, the dependencies, and a link to the Kconfig source. Clicking the option itself does not open the help.
• Dependency-aware controls: switches, tri-state m/y/n, choice groups, ranges for numbers ([2048 … 8192]). Options fixed by their dependencies are marked with 🔒.
• Text values (int, hex, string) are applied while you type, so the header counts them at once. Invalid numbers are not sent until they are valid.
• Unsaved changes count the options you edited. Options that changed only because of a dependency (for example, the other member of a choice) are shown as +N auto.
• Save writes sdkconfig (with sdkconfig.old as a backup) and regenerates build/config/*, so the next build picks the changes up. Discard reloads the file; Defaults resets to the defaults.

Set esp8266-idf.menuconfigUi to terminal for the classic idf.py menuconfig.

🗂 Sidebar

The ESP8266-IDF activity-bar container holds seven views — every one of them a draggable tab, and ESP › Return Views to the Sidebar brings any of them back home (since 1.92.0 the container is a stack of tabs, not one scrolling tree):

• Project & Commands — the daily loop: project folder, components, Build, Flash, Device, Clean, Port Settings, SDK Configure
• Serial Monitor — device output, input line, Timestamps / Autoscroll checkboxes, LF/CRLF/CR/raw line ending (persisted)
• Memory — size report charts straight from the .map file
• Utilities — Make SPIFFS / FATFS / LittleFS, Custom Partitions (partition table editor)
• OTA Partition Mgmt (Serial) — OTA Flash / Switch / Read Status / Erase
• Development Tools — the setup rows with live health state (1.93.0): Python (3.9+) and RTOS IDF carry their live state + the detected versions, and the toolchain reports itself — xtensa-gcc, gdb, objdump, esptool (bundled), OpenOCD (JTAG). One consistent state scheme (1.93.1, the avr-mdf 111.jpg canon): found = $(check) green, missing = $(warning) yellow — the severity lives in the description text. ESP › Refresh re-probes and re-runs the tools install check. 1.93.2: the Python probe strips the quotes from cached detection paths — a working Python never shows as "not found" again, and silent background probes never pop dialogs
• SDK Reference (1.93.0, DOUBLED in 1.93.2) — a curated, VERIFIED core of the ESP8266_RTOS_SDK v3.4 API: 36 modules, 213 functions, 22 macros (gpio, spi_flash, esp_wifi + the v3.4 event loop, esp_event, esp_now, esp_sleep, driver spi/i2c/hw_timer/i2s/ledc, esp_system, esp_heap_caps, esp_log, esp_timer, FreeRTOS task/queue/semphr/timers/event_groups, uart, pwm, adc, esp_http_client, esp_http_server, esp_https_ota, esp_ota_ops, esp_spiffs, mqtt_client, esp_task_wdt, tcpip_adapter, esp_vfs_dev, nvs_flash + nvs, the os_* compat shims, rom/ets_sys) with real signatures verified against the SDK's own headers; Insert #include (dedupe-checked, after the last include) and Function Details (Copy signature) ride the rows, and Open SDK include folder points at the authority — the SDK's own headers

⚙️ Build

• Build — full project build with configurable pre/post actions
• Build App — application only
• Build Bootloader — bootloader only
• Build Partition Table — partition table only
• Disassembly (1.93.0, ONE picker in 1.93.2, .obj objects in 1.93.4) — the avr-mdf/sdcc-mdf shape: the tree row and both palette commands open the SAME picker — the full firmware listing (xtensa-lx106-elf-objdump -d -S build/<app>.elf → build/<app>.lss, source-interleaved, reused while fresh by mtime) plus every object the build left (build/**/*.o and the ESP-IDF **/*.obj naming, -r relocations shown — works even when the link failed). A lone full listing opens directly; both old palette IDs are aliases of the one flow
• Stats + Flash button on success (1.93.0) — ✅ … blink.elf (Flash 258K/496K (52%) · RAM 42K/80K (53%)) with [Flash] [Memory] buttons; empty areas are never quoted (the sdcc noise rule)
• Errors → the Problems panel (1.93.0) — the launcher tees the build output; gcc file:line:col: error: records (up to 15, multi-file) land as diagnostics with a Go to Error button on the failure toast
• Build hooks (1.93.0) — esp8266-idf.hooks.preBuild / postBuild: arbitrary shell commands with ${workspaceFolder}, ${outputElf}, ${outputBin}, ${config:…}, ${env:…}; hooks.continueOnError + hooks.timeoutSec; live output in the ESP › Hooks terminal
• Auto-saves all unsaved files before build
• Pre-build action: none / clean / full clean
• Post-build action: none / flash / flash app
• COM port verified before build when post-build flash is selected

⚡ Flash

• Flash — flash full firmware to device
• Flash App — flash application only
• Flash Bootloader — flash bootloader only
• Flash Partition Table — flash partition table only
• Flash File System — flash filesystem image (.bin) to partition
  • Auto-detects filesystem type (SPIFFS / FATFS / LittleFS) from CMakeLists.txt
  • Reads esptool_py_flash_project_args block to determine type and partition offset
  • Falls back to manual selection if auto-detect fails
  • Auto-detects partition offset from partition table CSV
  • Uses esptool.py write_flash under the hood
• After-flash FS image (1.93.0) — esp8266-idf.postFlashFileSystem: every successful full flash also writes the CMake-linked FS image (single linked partition; missing image → actionable warning)
• Flash hooks (1.93.0) — esp8266-idf.hooks.preFlash / postFlash; the post-flash hook runs before the monitor opens in the flash & monitor chain, so the port is never contended
• Configurable erase before flash
• Configurable action after flash: none / monitor
• Port availability check before flashing
• If build/flasher_args.json is missing — automatically runs reconfigure first, then flash

🔧 Device (1.93.0)

• Read Flash Region — esptool.py read_flash <offset> <size> → build/flash-dump-<date>.bin; offset/size remembered; honest byte counter (toast only when the file really exists) + Open button
• Write Flash Region — any .bin at any offset (RF-cal region, storage outside the partition table) with a modal confirmation naming file/size/offset/port
• Erase Flash — full flash erase (moved here from Flash: flashing ships project artifacts, Device touches the chip)
• The esptool arguments are derived from the project's own configuration — --port, CONFIG_ESPTOOLPY_BAUD, and the --before/--after of build/flasher_args.json — never a second flasher

🖥️ Serial Monitor

• Dedicated Serial Monitor view (sidebar tab, draggable anywhere): device output, send-line input (LF/CRLF/CR), clear via the title-bar broom
• Toolbar: Timestamps (prefixes every line with [HH:MM:SS.mmm]) and Autoscroll (ON follows the newest line, OFF freezes the pane) as real checkboxes next to the Start/Stop button — state visible at a glance, persist across sessions (default: timestamps off, autoscroll on)
• The buttons wear the sdcc-mdf serial-monitor design (since 1.92.1): Start/Stop is the quiet secondary button in both states (no red, no glyphs — like the reference's Connect/Disconnect), Send is the primary one, both bigger and rounder (radius 4, 12px) with a hover dim and a press nudge; the send row's input and line-ending select are bordered (1px, radius 4) with a theme focus ring
• The monitor runs the bundled idf_monitor.py directly — no idf.py action banner in the log: the console shows pure device output
• Toolbar badge shows the connection — COM19 · 74880 baud — right when the view opens (before the first Start it is pre-filled with the configured port and the project's CONFIG_ESPTOOLPY_MONITOR_BAUD); after Stop it keeps the last session's values, and it refreshes dynamically the moment the configured port changes (port picker, settings.json, a flash-flow reselect) — a running session keeps its actual port until the next Stop
• Stop is three-stage (Ctrl+] → stdin EOF → process-tree kill) and always releases the COM port
• Monitor button in the status bar — red while running; Flash + Monitor chains automatically after a successful flash

🔧 SDK Configure

• Menuconfig — visual configuration in the web panel (or idf.py menuconfig in the terminal, see esp8266-idf.menuconfigUi)
• Reconfigure — re-run CMake
• Reset Projectconfig — delete sdkconfig and restore defaults on next build

📁 Project Folder

• Shows active project name
• 📂 root CMake editor — opens webview editor for root CMakeLists.txt
• 📄 main CMake editor — opens webview editor for main/CMakeLists.txt
• ✕ clear button — releases active project folder (visible only when folder is selected)
• Project folder selection always shows QuickPick menu — no auto-selection
• Cleared folder state persists across VS Code restarts
• 📦 Components — lists components/ subfolders with checkboxes
  • ☑️ / ☐ — toggle component compilation (writes EXCLUDE_COMPONENTS to CMakeLists.txt)
  • [+] — Create New Component
  • [✏️] — open CMake webview editor for component
  • [🗑] — delete component

⚙️ CMake Webview Editor

Visual editor for CMakeLists.txt — component, main, and root files.

• Format toggle — switch between Modern (idf_component_register) and Legacy (set(COMPONENT_SRCS ...) + register_component()) with header dropdown and badge
• All idf_component_register() parameters: SRCS/SRC_DIRS, EXCLUDE_SRCS, INCLUDE_DIRS, PRIV_INCLUDE_DIRS, REQUIRES, PRIV_REQUIRES, EMBED_FILES, EMBED_TXTFILES, LDFRAGMENTS
• Radio toggle between explicit SRCS list and auto-discover SRC_DIRS
• Built-in component picker with search/filter for REQUIRES/PRIV_REQUIRES
• Variable Reference Tags — ${VARIABLE} references in REQUIRES/PRIV_REQUIRES are shown as distinctive orange tags with 🔗 icon, clearly separating them from literal component names (grey tags)
  • Type ${COMPONENT_REQUIRES} or any ${VARIABLE} in the REQUIRES/PRIV_REQUIRES input field to add a variable reference
  • Variable references can also be added via the component picker
• Custom CMake Code (preamble) — collapsible section for editing CMake code that runs before idf_component_register() (e.g. if(CONFIG_BT_ENABLED) set(COMPONENT_REQUIRES bt) endif() conditional blocks)
  • Monospace textarea with syntax-highlighted preview
  • Collapsed by default, shows "(empty)" when no preamble code exists
  • Variable reference warning appears when ${...} patterns are detected in dependencies
• Custom CMake Code (postamble) — collapsible section for editing CMake code that appears after project() in root CMakeLists.txt
  • Includes partition bin links, if(CONFIG_...) blocks, esptool_py_flash_project_args() calls
  • Collapsed by default, syntax-highlighted in CMake Preview
• Live CMake preview with syntax highlighting (keywords, variables, strings, comments)
• Multiple editors can be open simultaneously
• Root editor: project name, EXCLUDE_COMPONENTS, EXTRA_COMPONENT_DIRS
• Busy State Protection — save is disabled during build/flash to prevent file corruption

➕ Create New Project

Webview-based project generator — all settings on one page:

• Parent folder browser, project name with live validation
• CMake style selector — Modern (idf_component_register) or Legacy (register_component) with Format dropdown and badge in header
• Header file location: include/ folder, same folder as .c, or none
• Excluded components picker
• Live preview of all files to be created
• Project automatically added to workspace and set as active after creation

📥 Import Project (1.92.0, restored in 1.93.0, the picker wizard in 1.93.2)

ESP › Import Project from Arduino / PlatformIO / Makefile / Eclipse… turns a foreign project into a working ESP8266-IDF one in place — every generated file lands next to the originals, nothing moves, nothing is modified. 1.93.2 — the avr-mdf/sdcc-mdf wizard shape: the command opens with the source-IDE picker (Arduino / PlatformIO / esp-open-rtos / ESP8266_NONOS_SDK / Eclipse CDT, each with a what-gets-imported detail), then one file dialog per format (.ino/.pde, platformio.ini, the Makefile, .cproject/.project), and the pick is validated against the chosen source — a NONOS Makefile under the esp-open-rtos entry gets an honest redirect, not a silent mis-import. The flow runs under the Import busy latch:

• Arduino sketch (.ino/.pde) — the sketch is converted exactly like the Arduino IDE builds it (primary file first, others alphabetically, auto-generated prototypes), setup()/loop() wrapped by a generated app_main FreeRTOS task, and a verified arduino-compat component over the native SDK drivers (pinMode/digitalWrite/analogRead/analogWrite/Serial/attachInterrupt/random/millis… — compiled against the real SDK). WiFi/HTTP/String and external libraries are detected and reported (⛔ blocking / ⚠️ warning) with native-API pointers — never silently dropped
• PlatformIO (platform=espressif8266) — framework=arduino goes through the sketch flow; framework=esp8266-rtos-sdk is a direct import; board → flash size → sdkconfig.defaults; -I/-D build flags map into main/CMakeLists.txt; every lib_deps entry gets its note
• Makefile — esp-open-rtos and ESP8266_NONOS_SDK layouts: structure + MODULES imported, with the honest API-port note (sdk_*/user_init/wifi_* do not exist on RTOS SDK v3.4)
• Eclipse CDT (.project/.cproject) — includes and defines extracted into the draft
• A pre-existing foreign CMakeLists.txt asks before anything is touched; the review step shows the verdict (clean / ⚠️ n warnings / ⛔ n blocking); README-IMPORT.md documents every created file, every ⛔/⚠️ and the next steps

➕ Create New Component

Webview-based component generator — all settings on one page:

• Component name with live validation and duplicate check
• CMake style selector — Modern (idf_component_register) or Legacy (register_component) with Format dropdown and badge in header
• Source files (.c) with inline add/remove
• Header file location: include/ folder, same folder as .c, or none
• Component dependencies (REQUIRES) picker with search/filter
• Live CMake preview with syntax highlighting

✏️ Edit Component

Webview-based component editor — all settings on one page:

• Pre-populated from existing CMakeLists.txt (name, sources, headers, dependencies)
• Component rename with automatic folder rename
• Source files (.c) with inline add/remove + auto-detect from directory
• Header file location: include/ folder, same folder as .c, or none (pre-selected)
• Component dependencies (REQUIRES) picker with search/filter (pre-populated)
• Live CMake preview with syntax highlighting
• "RENAMED" badge shown when component name is changed

⚙️ Settings Editor

Unified visual settings panel — per-command pre/post actions for Build and Flash:

• Build tab: Per-command Before/After actions for Build, Build App, Build Bootloader, Build Partition Table + shared Post-Build Analysis (Build only)
• Flash tab: Per-command Before/After actions for Flash, Flash App, Flash Bootloader, Flash Partition Table, Flash File System
• Esptool Connection settings and Override Flash Config are accessible via VS Code native Settings UI and sidebar tree commands (not in the webview)
• All settings displayed and editable with instant save

🛠️ Make SPIFFS

Pack any folder into a SPIFFS binary image using the bundled spiffsgen.py script.

• Opens folder picker (defaults to project root)
• Image size: Auto (minimum size calculated by spiffsgen.py) or manual input (bytes / KB / hex)
• SPIFFS parameters:
  • CONFIG_SPIFFS_PAGE_SIZE from sdkconfig → --page-size
  • CONFIG_WL_SECTOR_SIZE from sdkconfig → --block-size
  • --obj-name-len 32 (spiffsgen.py default, not configurable via ESP8266_RTOS_SDK)
  • --meta-len 4 (spiffsgen.py default, not configurable via ESP8266_RTOS_SDK)
  • --use-magic / --use-magic-len always enabled (spiffsgen.py defaults)
• --aligned-obj-ix-tables always enabled (required for ESP8266)
• Checks Python → SDK folder → project folder before running
• Saves <foldername>_spiffs.bin to project root

🛠️ Make FATFS

Pack any folder into a FAT filesystem image using the bundled fatfsgen.py / wl_fatfsgen.py scripts.

• Opens folder picker (defaults to project root)
• Image size: Auto (minimum size auto-detected by fatfsgen.py), presets, or manual input (bytes / KB / MB / hex)
• FATFS parameters:
  • CONFIG_WL_SECTOR_SIZE from sdkconfig → --sector_size
  • --sectors_per_cluster 1 (safe default, not configurable via ESP8266_RTOS_SDK)
  • --long_name_support always enabled for LFN compatibility
• Wear levelling mode selection: plain FATFS, WL performance, or WL safe mode
• When WL is selected, uses wl_fatfsgen.py instead of fatfsgen.py
• Zero dependencies — all scripts use only Python standard library (struct, argparse, os, etc.)
• Checks Python → SDK folder → project folder before running
• Saves <foldername>_fatfs.bin to project root

🛠️ Make LittleFS

Pack any folder into a LittleFS v2 filesystem image using the bundled littlefsgen.py script.

• Opens folder picker (defaults to project root)
• Image size: Auto (calculated from content), presets, or manual input (bytes / KB / hex)
• LittleFS parameters:
  • CONFIG_WL_SECTOR_SIZE from sdkconfig → --block_size
  • --name_max 32 (matches esp_littlefs component default)
• Pure Python — no external dependencies, compatible with Python 3.7+
• Supports inline files (small files stored in metadata pair) and CTZ skip-list files (large files)
• Additional CLI options: --disk_version, --compact, --no-pad, --follow-symlinks
• Checks Python → SDK folder → project folder before running
• Saves <foldername>_littlefs.bin to project root

🗂️ Partition Table Editor

Visual editor for ESP8266 flash partition tables — drag-and-drop, flash map, validation, bin linking.

• Drag-and-drop partition reordering (drag handle ⠿)
• Flash map visualization
• Theme-adaptive palette (1.93.4) — the flash-map chips, status colors and badges follow the VS Code theme kind (vscode-light / vscode-dark / vscode-high-contrast, live on theme switch), so custom themes never blend the text into the background
• Default Partition — standard single factory app layout
• Auto Offsets — automatic offset recalculation from PT end
• Reads PT offset, flash size and CSV filename from sdkconfig
• Link to bin — available only for fat and spiffs/littlefs subtypes
  • When a bin file is linked — SIZE is set automatically to match file size (rounded to 4096)
  • SIZE field becomes read-only while a bin is linked
  • On open — bin file sizes silently re-checked and SIZE updated if file changed
  • On Refresh — bin file sizes re-checked, partitions updated, missing files unlinked
  • On save — bin file checked against available area; save blocked if file is too large
  • Cross-platform CMake paths — bin file paths use ${CMAKE_CURRENT_SOURCE_DIR}/filename.bin instead of absolute paths for Windows/Linux/macOS compatibility
  • Auto-copy bin files — files outside the project directory are automatically copied to project root
  • Name collision handling — overwrite, keep existing, or auto-rename with numeric suffix
  • Migration of old absolute paths — old-style absolute paths are automatically converted to ${CMAKE_CURRENT_SOURCE_DIR}/ format
• Unsaved changes warning on close
• New partitions get unique names automatically
• Validation: alignment, overlaps, name length, duplicate names, custom subtype range
• TYPE: app / data / custom… (hex subtype 0x00–0xFE)
• DATA subtypes: nvs, ota, phy, fat, spiffs/littlefs
  • spiffs/littlefs — partition subtype 0x82, used by both SPIFFS and LittleFS filesystems. Saved as spiffs in CSV (ESP-IDF format).
• APP subtypes: factory, ota_0, ota_1

📡 OTA Partition Management (Serial)

Lives in its own OTA Partition Mgmt (Serial) sidebar view (since 1.92.0; every row also works from the Command Palette):

• OTA Flash — write firmware to OTA partition slot via serial
• OTA Switch — change boot partition (ota_0 / ota_1)
• OTA Read Status — read current OTA partition status
• OTA Erase — erase OTA partition data
• Serial port device connectivity check before OTA commands
• Auto-detects OTA partition layout from CSV; warns if no OTA slots found

🐞 Debugging

• Where the configurations live: in the project's .vscode/launch.json, written by the extension itself. When a project becomes active (restored at startup, selected, created, or the workspace folders changed), the two records — ESP8266-IDF: Debug (JTAG) and ESP8266-IDF: Attach to GDB Stub — are silently merged into the workspace folder's launch.json (merge-only: your own entries and formatting are never touched; delete .vscode/ and they reappear). Replace, not accumulate (1.93.6): the records list for the ACTIVE project only — switching the project moves them, removing the stale copies from the old folder (only entries exactly matching the generated records are removed; a copy you customized stays; a file that carried nothing but them is deleted). The Run-and-Debug selector then lists them like any hand-added configuration — one pair, for the active project. ESP › Add Debug Configurations to launch.json runs the sync manually and reports; esp8266-idf.debugSyncLaunchJson (default on) gates the automatic one. F5 with no launch.json at all still synthesizes the JTAG default when an ESP project is active.
• Post-mortem, no extra hardware (mode stub) — after a crash with CONFIG_ESP_PANIC_GDBSTUB the board waits for the debugger on the UART. The Serial Monitor's Crash Decoder symbolizes the panic backtrace through the toolchain's addr2line (clickable frames), and Attach Debugger starts an F5 session over the same USB-serial you flash with: Call Stack, Locals, Watch, FreeRTOS tasks as threads. The crashed core is frozen — inspection only.
• Live, through JTAG (mode jtag) — ESP-Prog or any JTAG adapter. F5 (pick ESP8266-IDF: Debug (JTAG) from the launch.json records, or just press it — the resolver synthesizes) or ESP › Debug with JTAG (OpenOCD): the extension generates the OpenOCD wrapper script (the shipped ESP-Prog/FT2232H interface cfg by default — override with esp8266-idf.debugOpenocdConfigs), starts the managed OpenOCD gdb server, and drives the same toolchain xtensa-lx106-elf-gdb in-process. Real breakpoints, continue, pause, step in/over/out, restart (reset + halt), watchpoints (data breakpoints), and FreeRTOS tasks as threads (auto-detected from the ELF; ESP › Enable FreeRTOS Thread Awareness adds the compat source when needed). OpenOCD state lives in the status bar and the ESP8266-IDF: OpenOCD output channel.
• Hardware limits, honestly surfaced — the LX106 has exactly one hardware breakpoint (XCHAL_NUM_IBREAK=1) and one hardware watchpoint (XCHAL_NUM_DBREAK=1). Software breakpoints land wherever OpenOCD can patch memory; code mapped from flash needs the hardware slot, and gdb's answer is reported verbatim (unverified breakpoints get an explaining tooltip).
• JTAG wiring (ESP-Prog → ESP8266EX): TDI→GPIO12/MTDI, TCK→GPIO13/MTCK, TMS→GPIO14/MTMS, TDO→GPIO15/MTDO, GND→GND. The UART stays free — the Serial Monitor can keep running while you debug.

Building the OpenOCD binary (one-time)

Mainline OpenOCD and espressif's fork ship no esp8266 target; the maintained fork is sysprogs/esp8266-openocd (source-only):

git clone --recursive https://github.com/sysprogs/esp8266-openocd
cd esp8266-openocd
./bootstrap && ./configure --enable-ftdi --disable-werror
make -j && sudo make install    # puts "openocd" on PATH

Windows: build in WSL or cross-compile, then point esp8266-idf.debugOpenocdPath at the openocd.exe. The gdb and addr2line it talks to are already in your ~/.espressif toolchain from ESP › Tools Install — no extra downloads.

📊 Analysis

• Size — firmware size report
• Size Components — per-component breakdown
• Size Files — per-file breakdown

🔧 VSCode Utilities (Command Palette)

• ESP › Regenerate IntelliSense Config — force-refreshes .vscode/c_cpp_properties.json (asks before overwriting)
  • Uses compile_commands.json as primary source (most accurate for Xtensa)
  • No intelliSenseMode override — C/C++ extension auto-detects from compile commands
• ESP › Regenerate tasks.json — force-refreshes the ESP build tasks for Ctrl+Shift+B (asks before overwriting)
• ESP › Return Views to the Sidebar — dragged the Serial Monitor or Memory tab into the Panel / Secondary Side Bar and want them back? This returns every view to its home (the ESP8266-IDF sidebar container). Works after a restart too — it is the built-in View: Reset View Locations under our name
• Since 1.91.2 these live in the palette only (F1) — repair/refresh actions are not the daily loop, so they no longer occupy a sidebar branch; the manual commands are the refresher half of the pair — see Auto-Generate Dev Files below for the primary (automatic) half

Auto-Generate Dev Files (the primary path)

• When autoGenerateOnOpen is enabled (default: true), the extension auto-generates .vscode/c_cpp_properties.json and .vscode/tasks.json — silently — when a project becomes the active one (project open, Select Project, an IDF-path change, a workspace-folders change)
• Only generates files that don't exist yet — existing files are never overwritten (the manual Regenerate commands are the explicit refresh)
• c_cpp_properties.json uses compile_commands.json as primary source for IntelliSense (most accurate for Xtensa); a stale compilerPath is self-healed on open
• tasks.json includes Build, Build App, Build Bootloader, Clean, Full Clean, Size tasks — and is self-healed when its embedded absolute paths (python/launcher/SDK) go stale; a user-edited tasks.json is never touched
• Problem matcher $esp-idf-gcc is registered for GCC error/warning format

🧰 Development Tools (sidebar view)

One view for what you set once (merged in 1.92.0 from the former 🐍 Python Path Settings and 🔗 SDK Path Settings tree branches):

• Python (3.9+): auto-detect — click to set a Python 3.9+ folder manually (or switch back to auto-detect; auto-detect prefers 3.11+)
• RTOS IDF: ESP8266_RTOS_SDK — click to point at the ESP8266_RTOS_SDK folder; the description shows the state — click to specify, (from environment), or error (invalid path)
• The rows refresh live: a settings.json edit or ESP › Set Python Path updates the labels immediately

📊 Status Bar

Quick access buttons: Build → Flash → Clean → Monitor → Menuconfig → COM port

⌨️ Keyboard Shortcuts

Requirements

• Python 3.9+ — any modern Python (3.9–3.13, 3.11+ recommended). The extension bundles its own modernized Python toolchain and creates a dedicated virtual environment automatically — no manual pip installs, no version pinning.
• ESP8266_RTOS_SDK

Setup

1. Install the extension
2. Set SDK path — click RTOS IDF: not set in the Development Tools sidebar view
3. Install build tools — extension installs them automatically via idf_tools.py: xtensa-lx106-elf (compiler), cmake, ninja
4. Select project folder — click Project Folder → folder not found in sidebar
5. Select COM port via Port Settings → Port in sidebar
6. Run Build → Flash → Monitor

Extension Settings

Supported Platforms

• ✅ Windows 10/11 (PowerShell)
• ✅ Linux (bash)
• ✅ macOS (bash/zsh)

Links

• GitHub Repository
• ESP8266_RTOS_SDK
• Report Issues

License

MIT