Answers for makers, prototypers, and embedded developers deciding whether ESP-GenUI fits their ESP32 project workflow.
ESP-GenUI is a visual diagramming tool for building ESP32 interfaces: a web page the board serves, the free ESP-GenUI phone app over Bluetooth, or a screen wired to the board itself. You drag modules onto a canvas, wire them together, preview the result, then generate firmware code for your ESP32.
You can design the interface visually without writing everything by hand. Some projects may still need small callback edits, especially when connecting widgets to hardware the app doesn't read for you, or to custom behavior — common DHT11/DHT22, BME280 and SHT31 temperature, humidity and pressure sensors need no code at all. When an edit of yours won't compile, Fix with AI can propose the change for you to review. The goal is to help you build cool looking embedded interfaces, without having to become a UI expert.
Yes. Click Describe, type what you're building in plain English, and the app assembles a matching diagram — pages, cards, widgets, and the wiring between them — that you can then preview, edit, and generate code from like any hand-drawn one. It's a fast way to start instead of a blank canvas. Ask for a reading shown as a picture ("an SHT31 with a thermometer that fills with the temperature") and it draws that too, already following the sensor. Mention a screen on the device ("and a small OLED on the box") and it sets that up as well, with pictures drawn for it. Building a diagram this way uses one AI generation credit (the Free plan includes a daily allowance).
Yes. Put a Draw node on the page, describe the picture in a sentence ("a barometer dial with Stormy, Rain, Change, Fair and Very Dry around the edge"), and Draw with AI makes a detailed drawing in about a minute. Its needles, levels and colors can follow your sensors or the device's clock live: pick which reading each moving part follows, and drag a slider to watch it respond before you flash anything. The drawing is data, not code, so it can't break your build, and the device draws exactly what the editor shows, on a web page, in the phone app, or on the board's own screen. Every drawing comes out different, even from the same description, so Redraw gives you a new take on the picture, not the same one again, and it replaces the drawing you had. Each drawing uses one AI generation credit, given back if no usable drawing comes back. To take one further by hand, Convert to code hands it over as an ordinary drawing callback you can edit. While a node holds a drawing it has no callback in Callbacks.h (main/app_callbacks.c on ESP-IDF): the drawing is generated into the firmware for you. Remove the drawing and Generate to get the stub.
Yes. Save to Gallery on a Draw node keeps its drawing in your account with a description you write, and the Gallery button on the canvas shows everything you've saved. Use adds a drawing to whatever project is open as a new Draw node, at the size it was drawn for, ready to wire into a page or card. It costs no credit, since the drawing is already made. Parts that followed a sensor follow the new project's sensor when it has one giving that reading (one temperature, say); otherwise you pick which in the Inspector. The Free plan keeps 3 drawings and Pro has no limit.
ESP-GenUI generates an Arduino sketch, or ESP-IDF source folder with files like demo.ino, Callbacks.h, EmbeddedSite.h, and/or main.c, etc. The generated code includes the interface (the web UI and its route handlers, the phone-app manifest, or the screen's pages), styling, and callback stubs.
No. Switch the Interface from Web to BLE and the firmware serves no website at all: it advertises your diagram as a compact Bluetooth UI manifest, and the free ESP-GenUI phone app reads it and draws native widgets — so there's no per-device app to write and no HTML on the chip. Both interfaces work on either framework (Arduino or ESP-IDF). A Wi-Fi device can also use Bluetooth just for onboarding, with the BLE Provisioning node handing it network credentials instead of a captive portal. And with the Interface set to On-device there's no remote interface at all: a device that shows what it does on its own screen, or does its job by itself, like a sensor that reports over MQTT. It still joins WiFi when something needs the network, without waiting for it.
Yes. Add a Display node and pick the panel, and it shows your pages: Draw pictures (a thermometer, a clock face, a tank level), gauges, progress bars, charts, tables and text, and QR and bar codes. The firmware draws them with no code and no graphics library, a page at a time, taking turns every few seconds or at the press of a button, or on a touch screen by a swipe. Your own code can put up a page too, say a night page at 22:00 or an alarm page when a reading crosses a limit. A page is laid out for the screen, with its header, cards, columns and widgets, and split into several screens when it's too tall; a page with one picture or gauge on it fills the screen. A page can be kept off the screen, or be on the screen only. It drives the Cheap Yellow Display (ESP32-2432S028R, either version), the Waveshare ESP32-S3-Touch-LCD-1.69 and the round Waveshare ESP32-S3-Knob-Touch-LCD-1.8, the M5Stack Core2, the round M5Stack M5Dial, the 3.5″ Guition JC3248W535 and the M5Stack M5Paper (a 4.7″ e-paper screen in 16 grays, with an E-paper theme to match) with no wiring at all, SSD1306 OLEDs (128×64 and 128×32), and ILI9341, ILI9342, ST7789 and round GC9A01 TFTs (SPI) and ST77916 and AXS15231B TFTs (QSPI) on pins you choose. On a touch screen (all of those boards, or your own panel with an XPT2046, CST816, FT6336 or FT3267 touch layer, or an AXS15231B's own) the page's buttons, sliders, steppers and selects work by touch and call the same code as on the web page, and a tap on a drawing can call your code with where it landed. The editor shows each one at the panel's own resolution, exactly as the board will draw it, and Draw with AI makes pictures for that screen: bold and one-color on an OLED. It works beside the web page or the phone app, or as the device's only interface. For any other ILI9341, ILI9342, ST7789, GC9A01 or SSD1306 screen, Find with AI looks your board up on the web and fills in its settings and pins for you to check. A test pattern at power-up shows which setting to change if the colors or orientation are off.
Yes. Put a QR/Bar Code node on a page and the device shows a code a phone or scanner can read: on its web page, in the phone app, or on its own screen. As a QR code it holds a link, a Wi-Fi network to join (WIFI:T:WPA;S:network;P:password;;), or any text; as a Code 128 bar code, ASCII text such as an order or part number; as an EAN-13 bar code, a 13-digit retail number. The board makes the code itself, so your code can change it while the device runs, with one call from any callback: setQrBarCode_<id>("…") on Arduino, set_qrbar_code_<id>("…") on ESP-IDF. That way it can show a link with the device's own address, or a new code for each order. The code is as big as the screen lets it be, black on white so phones read it, and for a QR code you choose how much damage it survives (its error correction). The editor's preview draws the same code the board will, so you can scan it off your monitor before you flash. It works on every interface: the board's web page and the phone app draw the same code, and follow your code's changes too.
Yes — ESP-GenUI for Android, free on Google Play, with no account and no network permission (it only talks Bluetooth to your own boards). It's one app for every device you build: it reads the interface off the board itself, so flashing a different diagram makes the same app show a different device — gauges, sliders, toggles, charts, schedules and color pickers, in the theme you picked in the editor. Devices are filtered by your account's fleet code, so a scan lists your hardware and not the workshop's. It can also update device firmware over Bluetooth, with no USB cable. iOS isn't on the App Store yet.
Two ways. Download ZIP gives you a ready-to-open sketch folder and works in any browser. On Chrome or Edge you can also use Save to Folder, which writes the files straight into a folder on your disk — no unzipping — and remembers it, so your editor (Arduino IDE, VS Code, etc.) picks up changes in place each time you save. There's also a per-file Copy and Download if you just want one file.
No. Callbacks.h is the one file you're meant to edit, and its stubs are keyed to each node — so renaming things in the diagram won't detach the code you've written. Regenerating merges rather than replaces: your filled-in bodies are kept and stubs for newly-added nodes are folded in beside them. demo.ino keeps your WIFI_SSID / WIFI_PASS too, unless the diagram's WiFi mode changed (which changes what those credentials mean — the app tells you when that happens). If a new stub can't be placed automatically, the built-in Diff/Merge tool opens so you choose what to keep instead of anything being guessed. And if you've used Save to Folder, your on-disk copies are the source of truth and that merge happens as you save.
Yes. ESP-GenUI can compile the generated firmware server-side and flash it to an ESP32 over USB from the browser using Web Serial. You do not need the Arduino IDE/ESP-IDF installed on your computer in order to test the generated source. It's one dialog: pick the board (or let Auto Detect Board read it from the chip), Compile, then Flash, which connects to the board over USB. If your board's USB adapter can't keep up at full speed, flashing drops to a slower speed by itself. You can also download the source code ZIP and use the Arduino IDE, or PlatformIO environment yourself.
The build log repeats the first error at the bottom, since that's the one that names the cause. When it's an error a change to your own code can fix (a typo, a missing declaration, a type mismatch), the Compile dialog also offers Fix with AI. It explains the problem and shows the proposed change as a diff; nothing is written until you click Apply & Recompile. Wi-Fi passwords and other credentials are removed before anything is sent. A fix uses one AI generation credit, given back if no usable fix comes back, and a failed compile itself costs nothing.
USB flashing requires a browser that supports the Web Serial API, so use a Chromium-based desktop browser such as Chrome or Edge. Sorry Firefox/Safari users: you can still design, generate and compile, and download the firmware to flash another way. Save to Folder needs Chrome or Edge too; Download ZIP works everywhere.
Every board in the ESP32 Arduino core's catalog — over 400, across the ESP32, S2, S3, C2, C3, C5, C6, C61, H2 and P4. A board is left out only when its chip can't do what your design needs: Bluetooth for the phone app (not the S2 or P4), or WiFi for a web page (not the H2, nor the P4 on ESP-IDF); the C2 and C61 build with ESP-IDF only. A device that runs on its own screen with no network builds for any of them. With the board plugged in over USB, the Compile dialog can detect its chip and choose the right build target, including the flash and PSRAM settings an ESP32-S3 needs. Boards with a screen built in, like the Cheap Yellow Display (ESP32-2432S028R), the Waveshare ESP32-S3-Touch-LCD-1.69, the M5Stack Core2 and the M5Paper, can show your pages on it with a Display node.
You can add pages, cards, text blocks, layout containers (tabs, columns, modals), forms, buttons, gauges, charts, tables, sliders, steppers, toggles, selects, color pickers, and a piano keyboard; custom pictures on a Draw node, made by AI from a description or drawn by your own code; status displays like LEDs, badges, alerts, progress bars, a live log/console, and a device-info panel; a live camera feed; an NTP clock and a time-of-day scheduler; hardware I/O (GPIO, PWM, ADC, servos, NeoPixel/WS2812 strips, and DHT11/DHT22/BME280/SHT31 temperature, humidity and pressure sensors); file managers and OTA upload controls; and connectivity such as WiFi setup flows, MQTT, WebSocket, mDNS, outbound webhooks, an HTTP Basic-Auth gate, and storage widgets; and the board's own screen, with a Display node — and more.
Yes. Some widgets generate direct firmware behavior for hardware like GPIO, PWM, ADC, servos, and NeoPixel/WS2812 strips. A Sensor node reads a DHT11, DHT22, BME280 or SHT31 for you, and any gauge, chart, stat card or progress bar can show one of its readings with no code to write, as can a Draw with AI picture such as a thermometer that fills. Other widgets expose callback stubs where you add your device-specific logic.
For many demo and simple workflows, yes: you can generate, compile, and flash in the browser. For deeper customization, you can still download the generated sketch and continue in the Arduino IDE or another editor. ESP-GenUI is NOT intended to be a replacement for your favorite development environment.
Yes. The built-in preview shows the web page your ESP32 will serve, using the same generated layout and styling, so you can adjust the design before compiling. For a phone-app device it shows the same layout with a note on how the app draws it, and with a Display it shows the board's screen at its own resolution, exactly as the board draws it, touch controls included.
Yes. Signed-in users can Save Project to the server and Load Project back later from the File menu. The Free plan keeps up to 3 saved projects and Pro has no limit — and at the Free cap you can still update projects you already have, only creating a new one is blocked. You can also Export Config to an encrypted .espgen file and import it again, which is the way to move a diagram between accounts or keep your own backup. Draw node pictures have a gallery of their own for reuse across projects.
Credits meter the server-side actions: code generation, compiling, and AI generation, each with its own separate daily pool that resets at midnight UTC. The AI pool covers all three AI features: Describe (a diagram from a description), Draw with AI (a picture for a Draw node) and Fix with AI (a proposed fix for a failed compile), one credit per use. The Free plan includes 15 code generations, 10 compiles, and 5 AI generations per day. Exporting or importing a config file also draws a code-gen credit.
Nothing is charged for work that produced nothing: re-generating an unchanged diagram is free, a compile is charged only when the build succeeds, and an AI drawing or fix that comes back empty is refunded. If you need more than the daily allowance, top-up packs are available for each pool and never expire — they're spent only once that day's free credits are gone.
Pro is $7.00/month or $70.00/year (a year costs the same as ten months). It removes the daily cap on code generation and compiles entirely, raises AI generations to 250 per day, lifts saved projects and saved drawings from 3 to unlimited and device functions per diagram from 15 to 250, and removes the ad slot. (Buying any credit pack removes the slot too — it only ever shows for accounts with no paid balance at all. On the Free plan the slot usually carries a first-party card for our own Android app, which sets no cookies and can be dismissed; a third-party ad appears there only if you accepted advertising cookies.)
Pro does not include commercial-use rights — that's the separate one-time license below, and the two are bought independently.
Yes, with the commercial-use license — a one-time $179 purchase, per account, bought from the Buy Credits cart or the Account & Plan panel. Without it, generated code is licensed for personal, non-commercial use, and each file says so in its header.
The license is separate from Pro: subscribing does not include it, and you don't need to subscribe to buy it. It also never expires — because it isn't tied to a subscription, there's nothing to lapse, and rights you bought stay bought. Questions about volume or bespoke terms? Contact us.
No. You can download the generated project files and keep editing them outside the app. ESP-GenUI is a generator, not a closed runtime requirement.