The ESP-IDF build process relies on a number of tools: cross-compiler toolchains, CMake build system, and others.
Installing the tools using an OS-specific package manager (e.g., apt, yum, brew, etc.) is the preferred method, when the required version of the tool is available. This recommendation is reflected in the Get Started. For example, on Linux and macOS, it is recommended to install CMake using an OS package manager.
However, some of the tools are specific to ESP-IDF and are not available in OS package repositories. Furthermore, different ESP-IDF versions require different tool versions for proper operation. To solve these two problems, ESP-IDF provides a set of scripts that can download and install the correct tool versions and set up the environment accordingly.
The rest of the document refers to these downloadable tools simply as "tools". Other kinds of tools used in ESP-IDF are:
Python scripts bundled with ESP-IDF such as idf.py
Python packages installed from PyPI
The following sections explain the installation method and provide the list of tools installed on each platform.
Note
This document is provided for advanced users who need to customize their installation, users who wish to understand the installation process, and ESP-IDF developers.
If you are looking for instructions on how to install the tools, see Get Started.
Tools Metadata FileïThe list of tools and tool versions required for each platform is located in tools/tools.json. The schema of this file is defined by tools/tools_schema.json.
This file is used by the tools/idf_tools.py script when installing the tools or setting up the environment variables.
Tools Installation DirectoryïThe IDF_TOOLS_PATH environment variable specifies the location where the tools are to be downloaded and installed. If not set, the default location will be HOME/.espressif on Linux and macOS, and %USER_PROFILE%\.espressif on Windows.
Inside the IDF_TOOLS_PATH directory, the tools installation scripts create the following directories and files:
dist â where the archives of the tools are downloaded.
tools â where the tools are extracted. The tools are extracted into subdirectories: tools/TOOL_NAME/VERSION/. This arrangement allows different versions of tools to be installed side by side.
idf-env.json â user install options, such as targets and features, are stored in this file. Targets are selected chip targets for which tools are installed and kept up-to-date. Features determine the Python package set which should be installed. These options will be discussed later.
python_env â not related to the tools; virtual Python environments are installed in the sub-directories. Note that the Python environment directory can be placed elsewhere by setting the IDF_PYTHON_ENV_PATH environment variable.
idf_version.txt â located within each specific Python environment sub-directory under python_env, this file records the ESP-IDF version corresponding to that environment. The version is stored in a format like 5.3 to represent ESP-IDF version v5.3.
espidf.constraints.*.txt â one constraint file for each ESP-IDF release containing Python package version requirements.
Most of the tools downloaded by the tools installer are GitHub Release Assets, which are files attached to a software release on GitHub.
If GitHub downloads are inaccessible or slow to access, a GitHub assets mirror can be configured.
To use Espressif's download server, set the environment variable IDF_GITHUB_ASSETS to dl.espressif.com/github_assets, or dl.espressif.cn/github_assets for faster download in China. When the install process is downloading a tool from github.com, the URL will be rewritten to use this server instead.
Any mirror server can be used provided the URL matches the github.com download URL format. For any GitHub asset URL that the install process downloads, it will replace https://github.com with https://${IDF_GITHUB_ASSETS}.
Note
The Espressif download server currently does not mirror everything from GitHub, but only files attached as Assets to some releases, as well as source archives for some releases.
idf_tools.py Scriptï
The tools/idf_tools.py script bundled with ESP-IDF performs several functions:
install: Download the tool into the ${IDF_TOOLS_PATH}/dist directory and extract it into ${IDF_TOOLS_PATH}/tools/TOOL_NAME/VERSION.
The install command accepts the list of tools to install in the TOOL_NAME or TOOL_NAME@VERSION format. If all is given, all the tools, including required and optional ones, are installed. If no argument or required is given, only the required tools are installed.
download: Similar to install but doesn't extract the tools. An optional --platform argument may be used to download the tools for the specific platform.
export: Lists the environment variables that need to be set to use the installed tools. For most of the tools, setting the PATH environment variable is sufficient, but some tools require extra environment variables.
The environment variables can be listed in either shell or key-value formats, which can be set using the --format parameter:
export optional parameters:
--unset: Creates a statement that unsets specific global variables and restores the environment to its state before calling export.{sh/fish}.
--add_paths_extras: Adds extra ESP-IDF-related paths of $PATH to ${IDF_TOOLS_PATH}/esp-idf.json, which is used to remove global variables when the active ESP-IDF environment is deactivated. For example, while processing the export.{sh/fish} script, if new paths are added to the global variable $PATH, this option saves these new paths to the ${IDF_TOOLS_PATH}/esp-idf.json file.
shell: Produces output suitable for evaluation in the shell. For example, produce the following output on Linux and macOS:
export PATH="/home/user/.espressif/tools/tool/v1.0.0/bin:$PATH"
Produce the following output on Windows:
set "PATH=C:\Users\user\.espressif\tools\v1.0.0\bin;%PATH%"
Note
Exporting environment variables in Powershell format is not supported at the moment. key-value format may be used instead.
The output of this command may be used to update the environment variables if the shell supports it. For example
eval $($IDF_PATH/tools/idf_tools.py export)
key-value: Produces output in the VARIABLE=VALUE format that is suitable for parsing by other scripts
PATH=/home/user/.espressif/tools/tool/v1.0.0:$PATH
Note that the script consuming this output has to perform expansion of $VAR or %VAR% patterns found in the output.
list: Lists the known versions of the tools, and indicates which ones are installed.
The following option is available to customize the output.
--outdated: Lists only outdated versions of tools installed in IDF_TOOLS_PATH.
check: For each tool, checks whether the tool is available in the system path and in IDF_TOOLS_PATH.
install-python-env: Creates a Python virtual environment in the ${IDF_TOOLS_PATH}/python_env directory or directly in the directory set by the IDF_PYTHON_ENV_PATH environment variable, and install the required Python packages there.
An optional --features argument allows one to specify a comma-separated list of features to be added or removed.
A feature that begins with - will be removed, and features with + or without any sign will be added. Example syntax for removing feature XY is --features=-XY, and for adding feature XY is --features=+XY or --features=XY. If both removing and adding options are provided with the same feature, no operation is performed.
For each feature, a requirements file must exist. For example, feature XY is a valid feature if ${IDF_PATH}/tools/requirements/requirements.XY.txt is an existing file with a list of Python packages to be installed.
There is one mandatory core feature ensuring the core functionality of ESP-IDF, e.g., build, flash, monitor, debug in console. There can be an arbitrary number of optional features.
The selected list of features is stored in idf-env.json.
The requirement files contain a list of the desired Python packages to be installed and the espidf.constraints.*.txt file downloaded from https://dl.espressif.com and stored in ${IDF_TOOLS_PATH}, which contains the package version requirements for a given ESP-IDF version.
Note
Although it is not recommended, the download and use of constraint files can be disabled with the --no-constraints argument or setting the IDF_PYTHON_CHECK_CONSTRAINTS environment variable to no.
check-python-dependencies: Checks if all required Python packages are installed. Packages from ${IDF_PATH}/tools/requirements/requirements.*.txt files selected by the feature list of idf-env.json are checked with the package versions specified in the espidf.constraints.*.txt file.
Note
The constraint file is downloaded with the install-python-env command. Similar to the install-python-env command, the use of constraint files can be disabled with the --no-constraints argument or setting the IDF_PYTHON_CHECK_CONSTRAINTS environment variable to no.
uninstall: Prints and removes tools that are currently not used by the active ESP-IDF version.
--dry-run: Prints installed unused tools.
--remove-archives: Additionally removes all older versions of previously downloaded installation packages.
Shell-specific user-facing installation scripts are provided in the root directory of ESP-IDF repository to facilitate tools installation. These are:
install.bat for Windows Command Prompt
install.ps1 for Powershell
install.sh for Bash
install.fish for Fish
Apart from downloading and installing the tools in IDF_TOOLS_PATH, these scripts prepare a Python virtual environment, and install the required packages into that environment.
These scripts accept optionally a comma-separated list of chip targets and --enable-* arguments for enabling features. These arguments are passed to the idf_tools.py script which stores them in idf-env.json. Therefore, chip targets and features can be enabled incrementally.
To install tools for all chip targets, run the scripts without any optional arguments using idf_tools.py install --targets=all. Similarly, to install Python packages for core ESP-IDF functionality, run idf_tools.py install-python-env --features=core.
It is also possible to install tools for specific chip targets. For example, install.sh esp32 installs tools only for ESP32. See Step 3. Set up the Tools for more examples.
install.sh --enable-XY enables feature XY (by running idf_tools.py install-python-env --features=core,XY).
Since the installed tools are not permanently added to the user or system PATH environment variable, an extra step is required to use them in the command line. The following scripts modify the environment variables in the current shell to make the correct versions of the tools available:
export.bat for Windows Command Prompt
export.ps1 for Powershell
export.sh for Bash
export.fish for Fish
Note
To modify the shell environment in Bash, export.sh must be "sourced" by using the command . ./export.sh. Please ensure to include the leading dot and space.
export.sh may be used with various shells like Bash, Zsh, sh, dash, etc. When using Bash or Zsh, you can run it from any path (e.g., . ./<<some_path>>/export.sh) as it automatically detects IDF_PATH. For other shells, it must be run from the ESP-IDF directory (. ./export.sh) to locate IDF_PATH correctly.
The environment setup is handled by the underlying tools/activate.py Python script. This script performs all necessary preparations and checks, generating a temporary file that is subsequently sourced by the export script.
activate.py can also function as a standalone command. When run, it launches a new child shell with an ESP-IDF environment, which can be utilized and then exited with the exit command. Upon exiting the child shell, you will return to the parent shell from which the script was initially executed.
Additionally, the specific behavior of the activate.py script can be modified with various options, such as spawning a specific shell with ESP-IDF using the --shell option. For more information on available options, use the activate.py --help command.
Note
When using activate.py on Windows, it should be executed with python activate.py. This ensures the script runs in the current terminal window rather than launching a new one that closes immediately.
Depending on the environment, more user-friendly wrappers for idf_tools.py are provided:
ESP-IDF Tools Installer can download and install the tools. Internally the installer uses idf_tools.py.
ESP-IDF Eclipse Plugin includes a menu item to set up the tools. Internally the plugin calls idf_tools.py.
VSCode ESP-IDF Extension includes an onboarding flow. This flow helps set up the tools. Although the extension does not rely on idf_tools.py, the same installation method is used.
Although the methods above are recommended for ESP-IDF users, they are not a must for building ESP-IDF applications. ESP-IDF build system expects that all the necessary tools are installed somewhere, and made available in the PATH.
When performing a custom installation, ensure that the ESP_IDF_VERSION environment variable is set to reflect the current ESP-IDF version, using a format like 5.3 to represent ESP-IDF version v5.3. This variable is required by some components for version-specific configurations and is typically set by the idf_tools.py export script in standard installations.
Uninstalling ESP-IDF requires removing both the tools and the environment variables that have been configured during the installation.
Windows users using the Windows ESP-IDF Tools Installer can simply run the uninstall wizard to remove ESP-IDF.
To remove an installation performed by running the supported install scripts, simply delete the tools installation directory including the downloaded and installed tools. Any environment variables set by the export scripts are not permanent and will not be present after opening a new environment.
When dealing with a custom installation, in addition to deleting the tools as mentioned above, you may also need to manually revert any changes to environment variables or system paths that were made to accommodate the ESP-IDF tools (e.g., IDF_PYTHON_ENV_PATH or IDF_TOOLS_PATH). If you manually copied any tools, you would need to track and delete those files manually.
If you installed any plugins like the ESP-IDF Eclipse Plugin or VSCode ESP-IDF Extension, you should follow the specific uninstallation instructions described in the documentation of those components.
Note
Uninstalling the ESP-IDF tools does not remove any project files or your code. Be mindful of what you are deleting to avoid losing any work. If you are unsure about a step, refer back to the installation instructions.
These instructions assume that the tools were installed following the procedures in this provided document. If you've used a custom installation method, you might need to adapt these instructions accordingly.
List of ESP-IDF Toolsï xtensa-esp-elf-gdbïGDB for Xtensa
License: GPL-3.0-or-later
More info: https://github.com/espressif/binutils-gdb
riscv32-esp-elf-gdbïGDB for RISC-V
License: GPL-3.0-or-later
More info: https://github.com/espressif/binutils-gdb
xtensa-esp-elfïToolchain for 32-bit Xtensa based on GCC
License: GPL-3.0-with-GCC-exception
More info: https://github.com/espressif/crosstool-NG
esp-clangïToolchain for all Espressif chips based on clang
License: Apache-2.0
More info: https://github.com/espressif/llvm-project
esp-clang-libsïStandalone Clang shared libraries distribution
License: Apache-2.0
More info: https://github.com/espressif/llvm-project
riscv32-esp-elfïToolchain for 32-bit RISC-V based on GCC
License: GPL-3.0-with-GCC-exception
More info: https://github.com/espressif/crosstool-NG
esp32ulp-elfïToolchain for ESP32 ULP coprocessor
License: GPL-3.0-or-later
More info: https://github.com/espressif/binutils-gdb
cmakeïCMake build system
On Linux and macOS, it is recommended to install CMake using the OS-specific package manager (like apt, yum, brew, etc.). However, for convenience it is possible to install CMake using idf_tools.py along with the other tools.
License: BSD-3-Clause
More info: https://github.com/Kitware/CMake
openocd-esp32ïOpenOCD for ESP32
License: GPL-2.0-only
More info: https://github.com/espressif/openocd-esp32
ninjaïNinja build system
On Linux and macOS, it is recommended to install ninja using the OS-specific package manager (like apt, yum, brew, etc.). However, for convenience it is possible to install ninja using idf_tools.py along with the other tools.
License: Apache-2.0
More info: https://github.com/ninja-build/ninja
idf-exeïIDF wrapper tool for Windows
License: Apache-2.0
More info: https://github.com/espressif/idf_py_exe_tool
ccacheïCcache (compiler cache)
License: GPL-3.0-or-later
More info: https://github.com/ccache/ccache
dfu-utilïdfu-util (Device Firmware Upgrade Utilities)
License: GPL-2.0-only
More info: http://dfu-util.sourceforge.net/
esp-rom-elfsïESP ROM ELFs
License: Apache-2.0
More info: https://github.com/espressif/esp-rom-elfs
qemu-xtensaïQEMU for Xtensa
Some ESP-specific instructions for running QEMU for Xtensa chips are here: https://github.com/espressif/esp-toolchain-docs/blob/main/qemu/esp32/README.md
License: GPL-2.0-only
More info: https://github.com/espressif/qemu
qemu-riscv32ïQEMU for RISC-V
Some ESP-specific instructions for running QEMU for RISC-V chips are here: https://github.com/espressif/esp-toolchain-docs/blob/main/qemu/esp32c3/README.md
License: GPL-2.0-only
More info: https://github.com/espressif/qemu
RetroSearch is an open source project built by @garambo | Open a GitHub Issue
Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo
HTML:
3.2
| Encoding:
UTF-8
| Version:
0.7.4