Today, we are taking a look at online tools for the ESP32, tools that require no more than a web browser.

Introduction

For years, working with an ESP32 usually meant installing the Arduino IDE, ESP-IDF, or PlatformIO – configuring board support packages, hunting for drivers, and debugging COM port mysteries before you had even written a single line of code. That is still the right approach for serious software development work, but it is no longer the only story.

Today, a growing collection of browser-based tools can talk directly to an ESP32 over USB. Without installing a traditional desktop toolchain, you can flash firmware, inspect the chip, open a serial monitor, manage the filesystem, configure Wi-Fi, and in some cases even write and compile your own code. These tools work on Windows, macOS, Linux, and ChromeOS. If you have a USB cable and a supported browser, you have everything you need.

In this article, we will look at four categories of online ESP32 tools, then explore the most useful examples in each category in depth. Along the way, there are demo ideas that translate directly to video, plus a comprehensive reference list of additional tools at the end.

Browser and Machine Requirements

All of the tools in this article use the Web Serial API, a browser technology that allows a web page to communicate directly with a USB serial port. The good news is that your machine requirements are minimal — almost any computer will work, you will not need to do any setup at all in most cases, and every tool covered here is completely free. Most of them do not even require an account.

Supported Browsers

The Web Serial API is supported in Chromium-based browsers version 89 or later. The following browsers all work well:

• Google Chrome (recommended)
• Microsoft Edge
• Opera
• Brave

The following browsers do not support Web Serial natively and will not work with these tools:

• Firefox — Mozilla has not implemented Web Serial. A third-party add-on exists but is unofficial.
• Safari — Apple has not implemented Web Serial on any platform.
• Any browser on iOS — all iOS browsers are forced to use Apple’s engine, so even Chrome on an iPhone will not work.

One important Linux-specific note: the Snap-packaged version of Chromium will not work because the Snap sandbox prevents access to serial ports. If you are on Ubuntu or a similar distribution and your port list is empty, check whether you installed Chromium via Snap. The fix is to install Google Chrome directly from Google or use a non-Snap Chromium package.

Operating System Notes

The table below summarises what you may need to do before these tools will see your board.

Operating System	What you may need to do
Windows 10/11	Usually works out of the box. If the board is not detected, install the CH340 or CP210x driver for your board’s USB chip, then check Device Manager.
macOS	Usually works. If not, install the driver for your USB chip, then go to System Settings → Privacy & Security and approve the kernel extension. Restart your Mac.
Linux	Drivers are built in. Add your user to the dialout group: sudo usermod -a -G dialout $USER then log out and back in. Do not use the Snap version of Chromium.

USB-to-UART Bridge Chips

Most classic ESP32 DevKit boards and budget boards use a separate USB-to-serial bridge chip. The three most common chips, and where to get drivers for them, are:

• CH340 / CH341 / CH9102 (WCH) — found on most inexpensive DevKits. Driver: wch-ic.com
• CP2102 / CP2104 (Silicon Labs) — found on many mid-range boards. Driver: silabs.com
• FTDI FT232 — found on higher-end boards. Driver: ftdichip.com

Boards with Built-in USB (No Driver Needed)

Newer ESP32 variants — including the ESP32-S2, ESP32-S3, ESP32-C3, ESP32-C6, ESP32-H2, and ESP32-C5 — have a built-in USB Serial/JTAG controller. These boards present themselves as standard CDC-ACM devices, which all modern operating systems handle natively. No driver installation is required at all. The XIAO ESP32C3, XIAO ESP32S3, and the ESP32-C6-DevKitC-1 covered in the demo section of this article all fall into this category.

The USB Cable

This trips up many people: make sure you are using a data-capable USB cable, not a charge-only cable. Many inexpensive USB and USB-C cables carry power but have no data lines, and none of these tools will work with them. If a board is not detected, try a different cable first — this is often the culprit.

The Four Categories of Online ESP32 Tools

Before diving into specific tools, it helps to understand the landscape. Online ESP32 tools fall into four broad categories. These categories also form the basis of the Keynote animation in the companion video.

1. Diagnostic Tools

Diagnostic tools connect to your board over USB and reveal detailed information about the chip itself — its family, revision, MAC address, flash memory size, PSRAM, partition layout, and more. The best ones go further, letting you browse and manage the onboard filesystem, inspect Non-Volatile Storage (NVS), monitor serial output, and even back up partitions. Think of these as the doctor’s stethoscope for your ESP32.

Animation idea: Magnifying glass over a chip. Text: “What chip is this? How much flash? What’s in the filesystem?”

Key example: ESPConnect

2. Firmware Flashing Tools

Firmware flashing tools — often called “.BIN tools” — handle the most common hardware maintenance task: pushing a pre-compiled binary file onto the chip over USB. They are the browser replacement for running esptool.py from the command line. You provide the .bin file; the tool handles the upload. No Python, no command line, no drivers beyond what your OS already has.

Animation idea: A .bin file arrow going into a chip. Progress bar fills.

Key examples: Espressif ESP Tool (esptool-js), ESPWEBTOOL

3. Software Installers

Software installers take firmware flashing to a much higher level of polish. Instead of asking the user to locate firmware files and set flash addresses, they present a single Install button. Behind the scenes, they automatically detect the connected chip, download the correct firmware variant, flash it, and optionally walk the user through Wi-Fi setup — all from the browser. This is what makes it possible for a non-technical user to install a complete application like WLED or Tasmota in under three minutes.

Animation idea: A single Install button. Chip auto-detected. Firmware downloads. Wi-Fi configured. Browser dashboard opens.

Key example: ESP Web Tools (and the projects built on top of it: WLED, ESPHome, Tasmota, ESPEasy, OpenDisplay)

4. Online IDEs

Online IDEs are the most ambitious category. These are browser-based development environments where you can write or edit code, manage libraries, compile, flash, and monitor – without installing a traditional desktop toolchain. Some compile locally on your machine, some compile in the cloud, and some take a different approach altogether, connecting directly to a MicroPython or CircuitPython interpreter running on the board for live, interactive development.

Animation idea: Browser window with a code editor. Code types itself. Compile cloud. Progress bar. LED blinks.

Key examples: FlashESP, Arduino Cloud Editor, ViperIDE, CircuitPython Online Editor

Note that the categories are not perfectly rigid. ESPConnect can also flash firmware. ESP Web Tools can display logs and assist with Wi-Fi setup. FlashESP sits somewhere between an installer and an IDE. That overlap is part of what makes the browser-based ESP32 world feel rich — and slightly unpredictable.

ESPConnect

URL: https://thelastoutpostworkshop.github.io/ESPConnect/

GitHub: https://github.com/thelastoutpostworkshop/ESPConnect

Overview

If there is one tool in this article that is most likely to make an experienced ESP32 user stop and say, “I didn’t know a browser could do that,” it is ESPConnect. Created by The Last Outpost Workshop, it is a browser-based control center for ESP32 and ESP8266-class boards that goes far beyond simple flashing. It runs entirely inside a Chromium browser with no backend, no account, and no telemetry — everything stays local.

ESPConnect supports an exceptionally wide range of chips: ESP32, ESP32-C3, ESP32-S2, ESP32-S3, ESP32-C5, ESP32-C6, ESP32-H2, ESP32-P4, and ESP8266. Once a board is connected, the navigation drawer unlocks a full suite of tools covering every major aspect of managing an ESP32.

Features

Device Info

The Device Info tab provides a comprehensive snapshot of the connected chip:

• Chip family, variant, and revision number
• MAC address
• Flash memory size, flash ID, and clock speed
• PSRAM presence and size
• USB-UART bridge details
• Flash security status
• Direct links to Espressif documentation, datasheets, technical reference manuals, and errata

Partitions

The Partitions tab provides a visual map of how the 4MB or 8MB of flash is divided. You can view the complete partition table with offsets and sizes, back up individual partitions or the full flash to a file on your computer, restore a partition from a saved backup, and identify active and inactive OTA slots. ESPConnect also integrates with an external ESP32 Partition Builder tool for designing custom partition layouts.

Filesystem Manager (SPIFFS / LittleFS / FATFS)

One of ESPConnect’s most impressive capabilities is its full filesystem manager, supporting all three common ESP32 filesystems. You can browse the directory structure, preview text files, images, and audio files directly in the browser, upload new files via drag and drop, download or delete individual files, and restore a complete filesystem image from a backup. For any project that stores configuration files, web pages, or data logs in flash, this is genuinely useful on the bench.

Apps

The Apps tab shows information about the firmware currently installed on the device — project name, version, compile date, and the ESP-IDF version used. If OTA update slots are configured, it shows which slot is active and which is available.

Flash Tools

The Flash tab handles firmware writing: upload one or more .bin files at specified memory addresses, erase the complete flash, and track progress visually. You can save device presets to quickly replicate a configuration across multiple identical boards — a real time-saver in classroom or production settings.

Serial Monitor

The built-in serial monitor streams live UART output from the board, lets you send commands, change baud rate, and reset the board without unplugging. It renders ANSI color escape sequences, supports pause/resume, and includes a copy-to-clipboard button. A Session Log records all connections, flashes, downloads, and warnings for the current session.

NVS Inspector (Experimental)

The Non-Volatile Storage Inspector is an advanced feature that reads the ESP32’s NVS partition — the area where the chip stores Wi-Fi credentials, device names, and application settings. It detects v1 or v2 NVS format, lists namespaces and keys, decodes common value types, and visualizes page layout and usage. The project explicitly labels this as experimental and read-only, which is worth stressing: it is an inspection tool, not a recovery or forensic tool.

Also Available As

ESPConnect is not only a website. It is also available as:

• A standalone Electron desktop app for Windows, macOS, and Linux — works completely offline
• A Docker container for local self-hosting
• A self-hosted static web app (download the dist.zip and serve it from any web server)

Using ESPConnect

ESPConnect lends itself to several strong on-camera demonstrations. For the smoothest video, pre-load two boards so you can jump between demos without changing firmware mid-scene.

Demo 1 — “What’s inside my ESP32?”

Connect any common ESP32 board — a DevKit V1, an ESP32-C6-DevKitC-1, or a XIAO ESP32-S3 all work well. Without loading any custom firmware at all, open ESPConnect, connect, and walk through the Device Info and Partitions tabs. Point out the chip family, flash size, MAC address, and the visual partition map. This is an easy, compelling introduction that works on any ESP32 board.

Demo 2 — Filesystem Manager

Pre-load a board with a sketch that creates a few files in SPIFFS or LittleFS — a config.json, a readme.txt, a log.txt, and a small HTML file are a good set. Open ESPConnect’s filesystem tab, browse the files, click to preview one, and download another. This is a vivid demonstration that the browser is not just flashing firmware — it is actively managing storage on the chip.

Demo 3 — Live Serial Monitor

Pre-load a board with a sketch that prints one line per second to Serial — sensor readings, a counter, or a simple “Welcome to the Workshop” message. Open ESPConnect’s Console tab and show the live stream. This is an easy-to-understand demonstration that the browser can replace the IDE’s serial monitor for many everyday tasks.

Demo 4 — NVS Inspector

Pre-load a sketch that writes a few values to Preferences (which uses NVS under the hood): a device name, a counter, a colour setting. Then open the NVS Inspector and show that those values really are stored in flash. This is the “wow, I didn’t know a browser could do that” moment of the demo.

.BIN Flashing Tools

Firmware is the underlying software installed in a microcontroller. There are occasions when you need to replace it — perhaps to update an old board, recover a bricked device, or distribute a pre-compiled project to someone who does not have an IDE. Firmware is packaged as .bin files, and the tools in this section are designed to flash those files onto your ESP32 directly from the browser.

Espressif ESP Tool (esptool-js)

URL: https://espressif.github.io/esptool-js/

GitHub: https://github.com/espressif/esptool-js

Espressif’s esptool-js is the official JavaScript implementation of their esptool utility, built on the Web Serial API. Because it comes from Espressif themselves, the company that designed the ESP32. It is the first tool to receive support for new chip variants and the reference against which other tools are measured.

It is worth understanding what esptool-js is and is not. Unlike the Python-based esptool, the JavaScript version does not generate binary images from ELF files and does not include companion tools such as espefuse.py or espsecure.py. It is a flashing tool: you bring the .bin file, and it handles getting that file onto the chip. The live demo at espressif.github.io/esptool-js is deliberately simple — connect, set baud rate, select file(s), click Program.

esptool-js is also worth knowing about because it is the engine powering many of the tools in this article, including ESPConnect and the Adafruit WebSerial ESPTool. Understanding the original helps explain why so many browser-based tools work so similarly.

Chip support: ESP32, ESP8266, ESP32-C2, ESP32-C3, ESP32-C5, ESP32-C6, ESP32-C61, ESP32-H2, ESP32-P4, ESP32-S2, ESP32-S3

ESPWEBTOOL (Spacehuhn)

URL: https://esptool.spacehuhn.com/

GitHub: https://github.com/SpacehuhnTech/espwebtool

ESPWEBTOOL was created by Stefan Kremser, known online as Spacehuhn, to make flashing his own ESP32 and ESP8266 projects as simple as possible for his users. It is based on the esp-web-flasher library and was inspired by esptool-js, but what Spacehuhn added is a clean, approachable interface with a few genuinely helpful user experience touches.

The workflow is exactly four steps: open the site, click Connect, choose your .bin file, and click Program. The default baud rate is 115,200 – adjustable if you want faster uploads. A useful tip for port identification: click Connect before plugging in your board, then plug it in. Whatever port appears in the dialog is the one for your board.

ESPWEBTOOL is the right tool to recommend to a complete beginner. Its strength is its simplicity. For anyone intimidated by command-line tools or IDE setup, being able to say “go to this URL, plug in your board, click Connect, choose your file, click Program” is genuinely transformative.

Chip support: ESP32, ESP8266, ESP32-S2, ESP32-S3, ESP32-C3

A Note on .BIN Files and Sketch Distribution

BIN files do not have to contain just stock firmware. You can compile your own Arduino sketches in the Arduino IDE and export them as .bin files using Sketch → Export Compiled Binary. That .bin file can then be flashed onto any compatible board using either of the tools above — with no Arduino IDE required on the receiving end. This is an excellent way to distribute your own projects to people who have an ESP32 but not a development environment.

Demonstrating .BIN Tools

Recommended Board: XIAO ESP32C3 or ESP32 DevKit V1

The XIAO ESP32C3 is a compact board with a USB-C connector, an onboard CH340 USB-UART chip that works reliably with Web Serial, and readily available pre-compiled firmware files from Seeed Studio. An ESP32 DevKit V1 is a good alternative.

Demo: Blink or Serial Hello World

Compile a simple Blink or “Hello from browser-flashed ESP32” sketch in Arduino IDE, then export it as a merged binary (.bin). In the video:

1. Open ESPWEBTOOL or espressif.github.io/esptool-js in Chrome or Edge
2. Click Connect, then plug in the board
3. Select the port that appears
4. Choose the .bin file
5. Click Program
6. Show the result — LED blinking, or serial output appearing in a browser terminal

You can also chain the two tools: flash with ESPWEBTOOL, then open ESPConnect’s Console tab to view the serial output. This shows two browser tools working together as a complete workflow.

ESP Web Tools

URL: https://esphome.github.io/esp-web-tools/

GitHub: https://github.com/esphome/esp-web-tools

Overview

ESP Web Tools, created by the ESPHome team at Nabu Casa (the company behind Home Assistant), is one of the most significant projects in the browser-based ESP32 world. It is not just a single installer website; it is a platform that other projects use to offer polished, one-click browser-based installation to their own users.

You can think of it in two ways at once. As a tool, the web page at esphome.github.io/esp-web-tools installs ESPHome firmware onto a connected board in one click, with automatic chip detection and optional Wi-Fi configuration. As a platform, it is an embeddable web component (an HTML element called esp-web-install-button) that any project developer can drop into their own website. This second role is why ESP Web Tools is everywhere in the ESP32 ecosystem — it powers the one-click installers for WLED, Tasmota, ESPEasy, and dozens of other projects.

How It Works

ESP Web Tools combines three ingredients:

1. Web Serial — the browser API for USB serial communication
2. A manifest file — a small JSON file hosted on the project’s server that lists the firmware files to download, their flash addresses, and which chip families are supported
3. Improv Wi-Fi (optional) — an open standard for configuring Wi-Fi credentials immediately after flashing, via the same serial connection

When you click an install button powered by ESP Web Tools, it: connects to the board via Web Serial, reads the chip type, downloads the correct firmware variant from the manifest URL, flashes it to the board, then optionally prompts for Wi-Fi credentials via Improv. The chip auto-detection is particularly powerful — the same install button handles ESP32, ESP32-S3, ESP32-C3, and other variants automatically, always installing the right binary.

Improv Wi-Fi

Improv Wi-Fi (improv-wifi.com) is an open standard developed alongside ESP Web Tools to remove the friction of configuring Wi-Fi on a freshly flashed ESP32. When firmware supports Improv, the installer prompts for your Wi-Fi network name and password immediately after flashing, sends them to the board over the serial connection, and the device joins your network automatically. No captive portal, no separate configuration page, no hardcoded credentials. You enter your Wi-Fi details in the browser once, and the device is on your network.

Projects That Use ESP Web Tools

The following major projects use ESP Web Tools for their browser installers. Each is worth mentioning in the article as a concrete example of what the platform makes possible.

WLED

Installer: https://install.wled.me

WLED is one of the most popular ESP32 projects in the maker community, an open-source firmware that turns an ESP32 into a powerful, Wi-Fi-controlled LED strip driver with over 100 built-in effects, segment control, music sync, preset storage, and smart home integration. The browser installer makes getting started effortless: connect your board, click Install, choose your firmware variant (plain, audioreactive, or ethernet), wait about two minutes, configure Wi-Fi via Improv, and you are done.

Note: the main installer at install.wled.me has periodically been offline for maintenance. An excellent backup is available at wled-install.github.io, which also offers additional build variants.

Testing WLED: Wire up a small ESP32 board with a short strip of WS2812B LEDs. Flash WLED from the browser installer, configure Wi-Fi via Improv, then open the WLED web interface in a second tab and start playing with effects. The visual payoff of addressable LEDs lighting up immediately after a browser-only install is very compelling on video.

For more information about using WLED, check out the article and video I created on the subject.

ESPHome

Web Installer: https://web.esphome.io

ESPHome is a system for configuring ESP32 and ESP8266 devices using YAML files for tight integration with Home Assistant. The web installer prepares a board for ESPHome in one click. ESPHome’s project page also offers a collection of ready-made browser-installed configurations: Bluetooth proxy, voice assistant, media player, infrared remote proxy, and a blank ESPHome device for custom configuration.

OpenDisplay Toolbox

URL: https://opendisplay.org/firmware/toolbox/index.html

OpenDisplay is a strong example of how far browser-based ESP tooling can extend beyond simple flashing. Its Toolbox page installs display firmware for supported ESP32-S3, ESP32-C3, and ESP32-C6 boards, then walks the user through selecting a display type (including many e-paper variants), choosing a driver board, setting display dimensions and color scheme, and applying a configuration — all in the browser. The tool even links to a BLE Tester and a Battery Life Calculator. It is a sophisticated, multi-step browser workflow built entirely on ESP Web Tools.

Tasmota

Web Installer: https://tasmota.github.io/install/

Tasmota is a widely used alternative firmware for ESP-based smart home devices, offering MQTT, HTTP, serial, and KNX control. Its web installer supports ESP8266 and ESP32 with a wide selection of firmware variants for different device types.

ESPEasy

Web Installer: https://td-er.nl/ESPEasy/

ESPEasy is a multi-sensor firmware platform for ESP8266 and ESP32, with web-based configuration and support for a large range of sensor types. The installer offers multiple build variants, including Climate, Display, Energy, NeoPixel, and Normal builds, for a wide range of ESP32 chip families.

FlashESP

URL: https://flashesp.com/

Public Project Explorer: https://flashesp.com/explore

What FlashESP Actually Is

FlashESP is probably the hardest tool in this article to describe simply, and that is not because it is complicated — it is because it sits across two categories at once.

FlashESP calls itself a “browser-based IDE,” which is technically accurate but slightly misleading at first glance. When you first visit the site, there is no code editor staring at you. What you see instead is a project dashboard and a public project explorer. That is intentional. FlashESP is not trying to replace Arduino IDE or PlatformIO for developers. It is a cloud-based build-and-deploy platform for ESP32 and ESP8266, built around small shareable Arduino projects.

The workflow is: create an account, start a new project, select your board from a dropdown, write or upload your Arduino sketch files in the browser editor, add libraries using the built-in library manager, click Build. Your code is compiled on FlashESP’s cloud servers with live logs appearing in the browser — then click Flash Device to send the result to your board via Web Serial.

The Project Sharing Feature

What makes FlashESP especially interesting for content creators and educators is its project visibility system. When you create a project, you can set it to Private (only you can see it), Unlisted (accessible via a direct link), or Public (listed on the FlashESP Explore page).

A public project can be flashed by anyone who visits its page — without an account, without installing anything, and without needing to see or understand the source code. This makes FlashESP a compelling distribution mechanism: write your project once, publish it, share the URL in a video or article, and readers can flash it to their own

boards with a single click.

FlashESP in Practice

As demonstrated in the companion video using the DHT22 demo project on FlashESP, the project page shows wiring instructions, board requirements, and a description of what the firmware does. Click Flash to Device, select the serial port, and the firmware is compiled and flashed entirely from the browser. The result is a Wi-Fi access point with a live temperature and humidity dashboard, and itworks exactly as described.

The project can then be opened in FlashESP’s browser editor, modified, rebuilt, and re-flashed. If you want to share a modified version, you can publish your own copy as a new project.

Current Capabilities and Limitations

• Arduino framework only — PlatformIO and ESP-IDF support are in development
• All Arduino IDE ESP32 and ESP8266 boards are supported; uses Arduino core 3.3.2 / ESP-IDF 5.5.1
• Up to 10 projects on the free tier; an account is required for creating projects
• Build errors are shown in live logs in the browser
• Public project explorer allows browsing and flashing others’ projects without an account
• GitHub synchronization is planned but not yet available

Note: The on-site demo button may not work with all boards at all times. If it fails, create an account, find the relevant project in the Explorer, and flash from there instead.

Online IDEs

The final category covers browser-based development environments — tools where you can write, edit, and in some cases compile and upload code entirely from the browser. These are for the times when you need to write code, not just flash pre-built firmware.

Arduino Cloud Editor

URL: https://app.arduino.cc/sketches

The Arduino Cloud Editor is the most complete browser-based C++ development environment for the ESP32 in the mainstream maker world. It is developed and maintained by Arduino itself, and it brings the full Arduino IDE experience to any browser.

How It Works

Unlike FlashESP, which compiles in the cloud and flashes via Web Serial, the Arduino Cloud Editor uses a small background application, the Arduino Create Agent, to handle USB serial communication. This agent requires a one-time installation on your computer. For Wi-Fi-capable boards like the ESP32, Over-the-Air (OTA) updates are also available once the device is provisioned to the Arduino Cloud, eliminating the need for a USB cable for subsequent updates.

Features

• Full Arduino IDE experience in the browser: code editor, library manager, board manager
• Sketches stored in the cloud and is accessible from any computer, any time
• Works with any board the Arduino IDE supports, including all ESP32 variants
• Built-in serial monitor
• Can push and pull sketches between the cloud and your local Arduino IDE
• AI assistant powered by Anthropic’s Claude – generates code, explains functions, and helps debug (Maker plan)
• OTA updates for Wi-Fi boards

Pricing

A free tier is available with limited features. The Maker plan at $6.99/month includes unlimited compilations, up to 25 devices, 3 months of data retention, and the AI assistant.

ViperIDE

URL: https://viper-ide.org

GitHub: https://github.com/vshymanskyy/ViperIDE

ViperIDE is a browser-based IDE for MicroPython and CircuitPython, created by Volodymyr Shymanskyy. If Python is your language of choice for the ESP32, ViperIDE is one of the best browser-based options available.

How It Works

ViperIDE connects to a MicroPython-powered ESP32 via USB, Bluetooth LE, or WebREPL over Wi-Fi. Once connected, the IDE gives you live access to the board’s filesystem and REPL. Unlike FlashESP, there is no cloud compilation step — MicroPython code is interpreted directly on the device, so the development cycle is just edit, save, and run.

Features

• Code editor with Python syntax highlighting
• File manager: browse, create, edit, and delete files on the connected device
• Terminal / REPL: interact directly with MicroPython running on the board
• Package manager: install MicroPython packages directly to the device
• Multiple connection methods: USB Serial, Bluetooth LE, WebREPL over Wi-Fi
• Experimental in-browser MicroPython emulator (no hardware required)
• Looks very similar to the Thonny IDE, which makes it immediately familiar

Prerequisite: Your ESP32 must already have MicroPython firmware installed. Use one of the .BIN flashing tools covered earlier in this article to install it from the official MicroPython download page at micropython.org/download.

Adafruit CircuitPython Code Editor

URL: https://code.circuitpython.org

Adafruit’s CircuitPython Code Editor is a browser-based editor for CircuitPython, Adafruit’s beginner-friendly Python dialect for microcontrollers. It supports ESP32 boards that have CircuitPython installed.

Connection Methods

Unlike ViperIDE, the CircuitPython editor offers three distinct connection methods:

• USB – direct connection via Web Serial. Best with boards that have native USB (ESP32-S2, ESP32-S3)
• Bluetooth LE – wireless connection to the board
• Web Workflow over Wi-Fi – once CircuitPython is configured with your Wi-Fi credentials, you can edit files and use the REPL entirely over the local network, with no USB cable at all

The Web Workflow feature is particularly notable for the ESP32. Classic ESP32 boards without native USB are now supported via Wi-Fi since CircuitPython 8, giving you a fully wireless, browser-based coding experience on inexpensive hardware.

Best boards for demo: Any board with an ESP32-S2 or ESP32-S3 chip and native USB — Adafruit Feather ESP32-S2, QT Py ESP32-S3, or XIAO ESP32-S3 — gives the cleanest experience.

Conclusion

The era of “you must install an IDE to do anything with an ESP32” is genuinely ending. The tools covered in this article cover the full spectrum from instant hardware diagnostics through one-click application installation to full browser-based code development. Between them, they mean that an ESP32 user with only a USB cable and a Chrome browser can now:

• Identify and inspect any ESP32 chip in detail
• Flash pre-compiled firmware from any .bin file
• Install complete applications like WLED, ESPHome, or Tasmota with a single click
• Browse, edit, and manage files stored in the ESP32’s flash filesystem
• Monitor serial output and interact with the board via a browser terminal
• Write, compile, and deploy Arduino code without installing anything locally
• Share a finished project so that anyone can flash it with no IDE

None of this replaces the Arduino IDE, ESP-IDF, or PlatformIO for serious software development. But it absolutely changes how we can teach, demonstrate, support, and distribute ESP32 projects. Whether you are a student on a Chromebook, a maker helping a friend get started, or an experienced developer doing a quick diagnostic in the field, there is now a browser-based tool for all of those situations.

Quick Reference — Tools Covered in This Article

Tool	Category	URL
ESPConnect	Diagnostics / Management	thelastoutpostworkshop.github.io/ESPConnect/
Espressif ESP Tool (esptool-js)	.BIN Flashing (Official)	espressif.github.io/esptool-js/
ESPWEBTOOL (Spacehuhn)	.BIN Flashing (Beginner)	esptool.spacehuhn.com
ESP Web Tools	Software Installer Platform	esphome.github.io/esp-web-tools/
WLED Installer	LED Controller Install	install.wled.me
ESPHome Web	Smart Home Firmware Install	web.esphome.io
OpenDisplay Toolbox	Display Firmware Install	opendisplay.org/firmware/toolbox/
Tasmota Installer	Smart Home Firmware Install	tasmota.github.io/install/
ESPEasy Installer	Multi-Sensor Firmware Install	td-er.nl/ESPEasy/
FlashESP	Cloud IDE / Project Sharing	flashesp.com
Arduino Cloud Editor	Online C++ IDE	app.arduino.cc/sketches
ViperIDE	MicroPython / CircuitPython IDE	viper-ide.org
CircuitPython Editor	CircuitPython IDE	code.circuitpython.org

Additional Online Tools for the ESP32

The following tools were not covered in depth in the main article or video, but are worth knowing about. Use this as a reference springboard for your own exploration.

Firmware Flashers

• Adafruit WebSerial ESPTool (adafruit.github.io/Adafruit_WebSerial_ESPTool/) – Supports flashing up to 4 .bin files at custom offsets. Excellent for CircuitPython and multi-part firmware. Actively maintained.
• ESPBoards.dev Flash Tool (espboards.dev/tools/program/) – Browser flasher with a built-in serial monitor. Part of a wider ESP32 toolkit.
• espflash.app (espflash.app) – Simple, clean browser flasher for merged/factory .bin files.
• ESPressoFlash (espressoflash.com) – Multi-step flasher with a chip-selection wizard. Supports separate Application, Bootloader, Partition Table, and NVS components.

Additional Software Installers

• WLED Backup Installer (wled-install.github.io) – Alternative WLED installer with additional build variants.
• Squeezelite-ESP32 (sle118.github.io/squeezelite-esp32-installer/) – Browser installer for Squeezelite, a streaming audio player firmware for ESP32.
• CanAirIO (canair.io/installer.html) – Browser installer for CanAirIO air quality monitoring firmware.
• OpenEpaperLink (https://openepaperlink.de/) – Another example of how far the browser-installer model has spread in the ESP32 ecosystem.

Serial Terminals and Monitors

• Spacehuhn Web Serial Terminal (terminal.spacehuhn.com) – A clean, no-frills browser serial terminal for ESP32, Arduino, and other USB serial devices. Useful when you want a monitor without a full diagnostic suite.
• Google Chrome Serial Terminal (googlechromelabs.github.io/serial-terminal/) – A reference Web Serial terminal from the Chrome team.
• ESPBoards.dev Serial Monitor (espboards.dev/tools/serial/) – Integrated serial monitor, part of the ESPBoards.dev toolkit.

Utility and Code Generation Tools

• ESPBoards.dev Tools (espboards.dev/tools/) – Beyond flashing, this site offers an OLED pixel art generator (8×8, 16×16, 32×32 for SSD1306 displays) and a buzzer melody sequencer that exports ready-to-use Arduino code.
• Wokwi (wokwi.com) – A full online ESP32 simulator and IDE. Write Arduino or MicroPython code and run it on a simulated ESP32 — with simulated sensors, displays, and other components. No real hardware required. Excellent for learning and prototyping.
• ESP Launchpad (espressif.github.io/esp-launchpad/) – Espressif’s official browser-based launcher for ESP32 example applications.
• PleaseDontCode (pleasedontcode.com) – AI-powered ESP32 sketch generation from natural language descriptions.
• TasmoCompiler (benzino77.github.io/tasmocompiler/) – Online custom Tasmota firmware builder. Configure your features and download a custom .bin.
• Web Serial Plotter (web-serial-plotter.atomic14.com) – Plots real-time data from a serial port in a browser graph. Useful for sensor visualization.

Partition Tools

• ESP32 Partition Builder (integrated in ESPConnect’s Partitions tab) — Web-based partition table designer.